workbench/network/stacks/AROSTCP/bsdsocket/kern/amiga_netdb.c

   1 /*
   2  * Copyright (C) 1993 AmiTCP/IP Group, <amitcp-group@hut.fi>
   3  *                    Helsinki University of Technology, Finland.
   4  *                    All rights reserved.
   5  * Copyright (C) 2005 - 2019 The AROS Dev Team
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  19  * MA 02111-1307, USA.
  20  *
  21  */
  22
  23 #include <conf.h>
  24
  25 #include <proto/dos.h>
  26 #include <proto/bsdsocket.h>
  27
  28 #include <dos/dos.h>
  29 #include <dos/rdargs.h>
  30
  31 #include <sys/param.h>
  32 #include <sys/systm.h>
  33 #include <sys/syslog.h>
  34 #include <sys/socket.h>
  35 #include <sys/malloc.h>
  36 #include <sys/mbuf.h>
  37
  38 #include <api/amiga_api.h>
  39 #include <kern/amiga_gui.h>
  40 #include <kern/amiga_includes.h>
  41 #include <kern/amiga_config.h>
  42 #include <kern/amiga_netdb.h>
  43 #include <kern/accesscontrol.h>
  44
  45 #include "net/netdbpaths.h"
  46 #include <net/sana2config.h>
  47 #include <net/route.h>
  48 #include <netinet/in.h>
  49 #include <protos/net/if_protos.h>
  50
  51 extern struct ifnet *iface_make(struct ssconfig *ifc);
  52
  53 LONG read_netdb(struct NetDataBase *ndb, UBYTE *fname,
  54                 UBYTE** errstrp, struct CSource *res,
  55                 int prefixindex, ULONG flags);
  56
  57 /*
  58  * Global pointer for the NetDataBase
  59  */
  60 struct NetDataBase *NDB = NULL;
  61
  62 /*
  63  * Global lock for the NetDatabase
  64  */
  65 struct SignalSemaphore ndb_Lock;
  66
  67 /*
  68  * Dynamic items Database (for entries supplied by DHCP)
  69  */
  70 struct DynDataBase DynDB;
  71
  72 /*
  73  * NDB Update Counter (used to keep resolver cache up to date)
  74  */
  75 ULONG ndb_Serial;
  76
  77 /*
  78  * Default netdatabase name
  79  */
  80 STRPTR netdbname = netdb_path;
  81
  82 /*
  83  * Templates for Arexx commands and DB files
  84  */
  85 STRPTR NETDBENTRY =
  86   "WITH,I=INTERFACE,H=HOST,N=NET,S=SERVICE,P=PROTOCOL,R=ROUTE,NS=NAMESERVER,DO=DOMAIN,RC,ACC=ACCESS";
  87
  88 enum ndbtype { KNDB_WITH, KNDB_IFACE, KNDB_HOST, KNDB_NET, KNDB_SERV, KNDB_PROTO,
  89                KNDB_RT, KNDB_DNS, KNDB_DOM, KNDB_RC, KNDB_ACC };
  90
  91 STRPTR NETDBTEMPLATE =
  92   "$NAME$/A,$ENTRY$/A,$ALIAS$/M";
  93
  94 STRPTR PROTOCOL_TEMPLATE =
  95   "$NAME$/A,$NUMBER$/A/N,$ALIAS$/M";
  96
  97 enum ndbarg { KNDB_NAME, KNDB_DATA, KNDB_ALIAS };
  98
  99 #define NDBARGS 3
 100
 101 STRPTR ROUTE_TEMPLATE =
 102   "HOST/S,NET/S,DEST/A,GW=GATEWAY/A";
 103
 104 enum rtarg { KRT_HOST, KRT_NET, KRT_DEST, KRT_GATE, RTARGS };
 105
 106 STRPTR ACCESS_TEMPLATE =
 107   "$PORT$/A,$HOSTMASK$/A,$ACCESS$/A,LOG/S";
 108
 109 enum accarg { KACC_PORT, KACC_HOSTMASK, KACC_ACCESS, KACC_LOG };
 110
 111 #define ACCARGS 4
 112
 113 STRPTR WITH_TEMPLATE =
 114   "$FILE$/A,PREFIX/K";
 115 #define WITHARGS 2
 116 enum witharg { WITH_FILE, WITH_PREFIX };
 117
 118 /* prototypes for the netdb parsing functions */
 119
 120 LONG addwith(struct NetDataBase *ndb,
 121              struct RDArgs *rdargs, UBYTE **errstrp, struct CSource *res, ULONG flags);
 122 LONG addifent(struct NetDataBase *ndb,
 123                 struct RDArgs *rdargs, UBYTE **errstrp, struct CSource *res, ULONG flags);
 124 LONG addhostent(struct NetDataBase *ndb,
 125                 struct RDArgs *rdargs, UBYTE **errstrp, struct CSource *res, ULONG flags);
 126 LONG addnetent(struct NetDataBase *ndb,
 127                struct RDArgs *rdargs, UBYTE **errstrp, struct CSource *res, ULONG flags);
 128 LONG addservent(struct NetDataBase *ndb,
 129                 struct RDArgs *rdargs, UBYTE **errstrp, struct CSource *res, ULONG flags);
 130 LONG addprotoent(struct NetDataBase *ndb,
 131                  struct RDArgs *rdargs, UBYTE **errstrp, struct CSource *res, ULONG flags);
 132 LONG addrtent(struct NetDataBase *ndb,
 133                 struct RDArgs *rdargs, UBYTE **errstrp, struct CSource *res, ULONG flags);
 134 LONG addnameservent(struct NetDataBase *ndb,
 135                     struct RDArgs *rdargs, UBYTE **errstrp, struct CSource *res, ULONG flags);
 136 LONG adddomainent(struct NetDataBase *ndb,
 137                   struct RDArgs *rdargs, UBYTE **errstrp, struct CSource *res, ULONG flags);
 138 LONG addrcent(struct NetDataBase *ndb,
 139                     struct RDArgs *rdargs, UBYTE **errstrp, struct CSource *res, ULONG flags);
 140 LONG addaccessent(struct NetDataBase *ndb,
 141                   struct RDArgs *rdargs, UBYTE **errstrp, struct CSource *res, ULONG flags);
 142 LONG addndbent(struct NetDataBase *ndb,
 143                struct RDArgs *rdargs, UBYTE **errstrp, struct CSource *res, ULONG ifflags);
 144
 145 typedef LONG (*ndb_parse_f)(struct NetDataBase *ndb,
 146             struct RDArgs *rdargs, UBYTE **errstrp, struct CSource *res, ULONG flags);
 147
 148 /* Array of parsing functions. Note that the order is same as in the
 149  * NETDBENTRY.
 150  */
 151 ndb_parse_f ndb_parse_funs[] = {
 152   addwith,
 153   addifent,
 154   addhostent,
 155   addnetent,
 156   addservent,
 157   addprotoent,
 158   addrtent,
 159   addnameservent,
 160   adddomainent,
 161   addrcent,
 162   addaccessent
 163 };
 164
 165 /*
 166  * Alloc a NetDataBase
 167  */
 168 struct NetDataBase *
 169 alloc_netdb(struct NetDataBase *ndb)
 170 {
 171 #if defined(__AROS__)
 172 D(bug("[AROSTCP](amiga_netdb.c) alloc_netdb()\n"));
 173 #endif
 174
 175   if (ndb ||
 176       (ndb = bsd_malloc(sizeof (*NDB), M_NETDB, M_WAITOK))) {
 177     struct MinList *gl;
 178
 179     for (gl = (struct MinList *)&ndb->ndb_Hosts;
 180          gl <= (struct MinList *)&ndb->ndb_Domains;
 181          gl++)
 182       NewList((struct List *)gl);
 183
 184   }
 185
 186   ndb->ndb_AccessCount = 0;
 187   if ((ndb->ndb_AccessTable =
 188        bsd_malloc(TMPACTSIZE, M_NETDB, M_WAITOK)) == NULL) {
 189     bsd_free(ndb, M_NETDB);
 190     ndb = NULL;
 191   }
 192 #if defined(__AROS__)
 193 D(bug("[AROSTCP](amiga_netdb.c) alloc_netdb: Allocated ndb = 0x%p, ndb_AccessTable = 0x%p\n", ndb, ndb->ndb_AccessTable));
 194 #endif
 195   DNETDB(else __log(LOG_DEBUG,"Allocated ndb = 0x%p, ndb_AccessTable = 0x%p", ndb, ndb->ndb_AccessTable);)
 196   return ndb;
 197 }
 198
 199 /*
 200  * Free a NetDataBase
 201  * Caller must have a write lock on NDB
 202  */
 203 void
 204 free_netdb(struct NetDataBase *ndb)
 205 {
 206   struct GenentNode *gn;
 207   struct MinList *gl;
 208 #if defined(__AROS__)
 209 D(bug("[AROSTCP](amiga_netdb.c) free_netdb( 0x%p )\n", ndb));
 210 #endif
 211   for (gl = (struct MinList *)&ndb->ndb_Hosts;
 212        gl <= (struct MinList *)&ndb->ndb_Domains;
 213        gl++)
 214     while (gn = (struct GenentNode *)RemHead((struct List *)gl))
 215       bsd_free(gn, M_NETDB);
 216
 217   if (ndb->ndb_AccessTable != NULL) {
 218     bsd_free(ndb->ndb_AccessTable, M_NETDB);
 219     ndb->ndb_AccessTable = NULL;
 220   }
 221   bsd_free(ndb, M_NETDB);
 222 }
 223
 224 #ifdef DEBUG
 225 static UBYTE * zap;
 226 static size_t zap_size;
 227 #endif
 228
 229 /*
 230  * Copy alias list to ato, alias strings and name to cto
 231  */
 232 static void
 233 aliascpy(UBYTE *cto, UBYTE *name, UBYTE**ato, UBYTE **afrom)
 234 {
 235 #ifdef DEBUG
 236   UBYTE *logname = name;
 237 #endif
 238 #if defined(__AROS__)
 239 D(bug("[AROSTCP](amiga_netdb.c) aliascopy()\n"));
 240 #endif
 241
 242   do {
 243     while(*cto++ = *name++);
 244   } while (afrom && (name = *afrom++) && (*ato++ = cto));
 245
 246   *ato = NULL;
 247
 248 #ifdef DEBUG
 249   if (cto != zap + zap_size) {
 250     __log(LOG_ERR, "%s: mismatch in size %ld != expected %ld\n",
 251         logname, cto - (UBYTE *)zap, zap_size);
 252   }
 253 #endif
 254 }
 255
 256 /*
 257  * Allocate a netdb node
 258  *
 259  * nodesize is the size of the base structure, additional space
 260  * is allocated for the name and the aliases.
 261  * alias is NULL terminated array of alias name pointers.
 262  * Number of aliases is returned via aliasp.
 263  *
 264  * size field of the allocated node is set to the total size - size for
 265  * the MinNode and the size field itself.
 266  */
 267 static void *
 268 node_alloc(size_t nodesize, UBYTE *name, UBYTE **alias, int *aliasp)
 269 {
 270   struct GenentNode *gn;
 271 #if defined(__AROS__)
 272 D(bug("[AROSTCP](amiga_netdb.c) node_alloc()\n"));
 273 #endif
 274
 275   nodesize += strlen(name) + 1; /* Add space needed for the name */
 276
 277   *aliasp = 1;
 278   nodesize += sizeof (char*);   /* Alias list NULL terminator */
 279
 280   /* Calculate the size of the aliases */
 281   if (alias) {
 282     while (*alias) {
 283       (*aliasp)++;
 284       nodesize += strlen(*alias++) + 1 + sizeof (char*);
 285     }
 286   }
 287   gn = bsd_malloc(nodesize, M_NETDB, M_WAITOK);
 288   /*
 289    * set the ent size
 290    */
 291   if (gn)
 292     gn->gn_EntSize = nodesize - sizeof (struct GenentNode);
 293
 294 #ifdef DEBUG
 295   zap_size = nodesize;
 296   zap = (char *)gn;
 297 #endif
 298   return gn;
 299 }
 300
 301 /*
 302  * Parse an include entry.
 303  */
 304 LONG
 305 addwith(struct NetDataBase *ndb,
 306         struct RDArgs *rdargs,
 307         UBYTE **errstrp, struct CSource *res, ULONG flags)
 308 {
 309   // UBYTE result[REPLYBUFLEN + 1];
 310 //struct CSource res;
 311   LONG retval = RETURN_OK;
 312   IPTR Args[WITHARGS] = { 0 };
 313   int which;
 314
 315 #if defined(__AROS__)
 316 D(bug("[AROSTCP](amiga_netdb.c) addwith()\n"));
 317 #endif
 318
 319 /*  res.CS_Buffer = result;
 320   res.CS_Length = sizeof (result);
 321   res.CS_CurChr = 0;*/
 322
 323   if (rdargs = ReadArgs(WITH_TEMPLATE, Args, rdargs)) {
 324     if (Args[WITH_PREFIX] == 0) /* no prefix given */
 325       which = -1;
 326     else {
 327       /* match given prefix */
 328       which = FindArg(NETDBENTRY, (UBYTE *)Args[WITH_PREFIX]);
 329       if (which < 0) {
 330         *errstrp = ERR_VALUE;
 331         retval = RETURN_WARN;
 332       }
 333     }
 334     if (retval == RETURN_OK) {
 335       retval = read_netdb(ndb, (UBYTE *)Args[WITH_FILE], errstrp, res,
 336                           which, flags);
 337     }
 338     FreeArgs(rdargs);
 339   } else {
 340     *errstrp = ERR_SYNTAX; retval = RETURN_WARN;
 341   }
 342   return retval;
 343 }
 344
 345 /* Copy an address */
 346 static int inline setaddr(struct sockaddr_in *sa, char *addr, u_short af)
 347 {
 348   sa->sin_len = sizeof(struct sockaddr_in);
 349   sa->sin_family = af;
 350   return __inet_aton(addr, &sa->sin_addr);
 351 }
 352
 353 /*
 354  * Parse an interface entry.
 355  */
 356 LONG
 357 addifent(struct NetDataBase *ndb,
 358             struct RDArgs *rdargs,
 359             UBYTE **errstrp, struct CSource *res, ULONG flags)
 360 {
 361   struct ssconfig *ssc;
 362   struct ifnet *ifp;
 363   struct ifaliasreq ifr;
 364   char *cp, *ep;
 365   LONG retval = RETURN_OK;
 366
 367 #if defined(__AROS__)
 368 D(bug("[AROSTCP](amiga_netdb.c) addifent()\n"));
 369 #endif
 370
 371   if (flags & (NETDB_IFF_MODIFYOLD|NETDB_IFF_ADDNEW)) {
 372         ssc = ssconfig_parse(rdargs);
 373         if (ssc) {
 374                 ifp = ifunit(ssc->args->a_name);
 375                 if ((!ifp) && (flags & NETDB_IFF_ADDNEW)) {
 376                         DIFCONF(Printf("Adding new interface %s\n", ssc->args->a_name);)
 377                         cp = strncpy(ssc->name, ssc->args->a_name, IFNAMSIZ);
 378                         ssc->name[IFNAMSIZ-1] = '\0';
 379
 380                         for (; *cp; cp++)
 381                                 if (*cp >= '0' && *cp <= '9')
 382                                         break;
 383
 384                         ep = cp;
 385                         for (ssc->unit = 0; *cp >= '0' && *cp <= '9'; )
 386                                 ssc->unit = ssc->unit * 10 + *cp++ - '0';
 387
 388                         *ep = 0;
 389                         ifp = iface_make(ssc);
 390                         if (!ifp) {
 391 #if defined(__AROS__)
 392 D(bug("[AROSTCP](amiga_netdb.c) addifent: failed to create interface '%s'\n", ssc->args->a_name));
 393 #endif
 394                                 *errstrp = ERR_MEMORY;
 395                                 retval = RETURN_FAIL;
 396                         }
 397                         else
 398                         {
 399 #if defined(__AROS__)
 400 D(bug("[AROSTCP](amiga_netdb.c) addifent: created new interface '%s'\n", ssc->args->a_name));
 401 #endif
 402                                 flags |= NETDB_IFF_MODIFYOLD;
 403                         }
 404                 }
 405                 if ((ifp) && (flags & NETDB_IFF_MODIFYOLD))
 406                 {
 407 #if defined(__AROS__)
 408 D(bug("[AROSTCP](amiga_netdb.c) addifent: configuring interface '%s'\n", ssc->args->a_name));
 409 #endif
 410                         DIFCONF(Printf("Setting up interface %s\n", ssc->args->a_name);)
 411                         memset (&ifr, 0, sizeof (ifr));
 412                         if (ssc->args->a_ip) {
 413                                 if (!ssc->args->a_up) {
 414                                         DIFCONF(Printf("> No auto-online\n");)
 415                                         ifp->if_flags |= IFF_NOUP;
 416                                 }
 417                                 DIFCONF(Printf("> IP address: %s\n", ssc->args->a_ip);)
 418                                 if (stricmp(ssc->args->a_ip, "DHCP")) {
 419                                         ifp->if_data.ifi_aros_usedhcp = 0;
 420                                         if (setaddr ((struct sockaddr_in *)&ifr.ifra_addr, ssc->args->a_ip, AF_INET)) {
 421                                                 if (ssc->args->a_netmask) {
 422                                                         DIFCONF(Printf("> Netmask: %s\n", ssc->args->a_netmask);)
 423                                                         if (!setaddr ((struct sockaddr_in *)&ifr.ifra_mask, ssc->args->a_netmask, AF_UNSPEC)) {
 424                                                                 *errstrp = ERR_SYNTAX;
 425                                                                 retval = RETURN_WARN;
 426                                                         }
 427                                                 }
 428                                                 in_control(NULL, SIOCAIFADDR, &ifr, ifp);
 429                                         } else {
 430                                                 *errstrp = ERR_SYNTAX;
 431                                                 retval = RETURN_WARN;
 432                                         }
 433                                 } else {
 434                                         DIFCONF(Printf("> Using DHCP\n");)
 435                                         ifp->if_data.ifi_aros_usedhcp = 1;
 436                                         if (ssc->args->a_up) {
 437                                                 if (api_state == API_SHOWN)
 438                                                         run_dhclient(ifp);
 439                                                 else
 440                                                         ifp->if_flags |= IFF_DELAYUP;
 441                                         }
 442                                 }
 443                         }
 444                 }
 445                 else
 446                 {
 447 #if defined(__AROS__)
 448 D(bug("[AROSTCP](amiga_netdb.c) addifent: Interface named '%s' already exists..\n", ssc->args->a_name));
 449 #endif
 450                 }
 451                 ssconfig_free(ssc);
 452         } else {
 453                 *errstrp = ERR_SYNTAX;
 454                 retval = RETURN_WARN;
 455         }
 456   }
 457   return retval;
 458 }
 459
 460
 461 /*
 462  * Parse a service entry.
 463  */
 464 LONG
 465 addservent(struct NetDataBase *ndb,
 466             struct RDArgs *rdargs,
 467             UBYTE **errstrp, struct CSource *res, ULONG flags)
 468 {
 469   LONG retval;
 470   IPTR Args[NDBARGS] = { 0 };
 471   struct ServentNode *sn;
 472   int aliases, plen;
 473
 474 #if defined(__AROS__)
 475 D(bug("[AROSTCP](amiga_netdb.c) addservent()\n"));
 476 #endif
 477
 478   if (rdargs = ReadArgs(NETDBTEMPLATE, Args, rdargs)) {
 479     /* convert port number */
 480     UBYTE *s_proto = (UBYTE*)Args[KNDB_DATA];
 481     LONG tmp;
 482     if ((plen = StrToLong(s_proto, &tmp)) > 0 &&
 483         s_proto[plen++] == '/') {
 484       Args[KNDB_DATA] = tmp;
 485       int protonamelen = strlen(s_proto = s_proto + plen) + 1;
 486       sn = node_alloc(sizeof (*sn) + protonamelen,
 487                       (UBYTE*)Args[KNDB_NAME],
 488                       (UBYTE **)Args[KNDB_ALIAS], &aliases);
 489       if (sn) {
 490         UBYTE **alias = (UBYTE **)(sn+1);
 491         UBYTE *name = (UBYTE *)(alias + aliases);
 492
 493         sn->sn_Ent.s_port = Args[KNDB_DATA];
 494         sn->sn_Ent.s_proto = strcpy(name, s_proto);
 495         sn->sn_Ent.s_name = name + protonamelen;
 496         sn->sn_Ent.s_aliases = (char **)alias;
 497
 498         /* Copy aliases */
 499         aliascpy(sn->sn_Ent.s_name, (UBYTE*)Args[KNDB_NAME],
 500                  alias, (UBYTE **)Args[KNDB_ALIAS]);
 501         AddTail((struct List*)&ndb->ndb_Services, (struct Node*)sn);
 502         retval = RETURN_OK;
 503       } else {
 504         *errstrp = ERR_MEMORY; retval = RETURN_FAIL;
 505       }
 506     } else {
 507       *errstrp = ERR_VALUE; retval = RETURN_WARN;
 508     }
 509     FreeArgs(rdargs);
 510   } else {
 511     *errstrp = ERR_SYNTAX; retval = RETURN_WARN;
 512   }
 513   return retval;
 514 }
 515
 516 /*
 517  * Parse a host entry.
 518  *
 519  * NOTE: The host entry has the address in the 'name' and the official name
 520  * in the 'data'.
 521  */
 522 LONG
 523 addhostent(struct NetDataBase *ndb,
 524             struct RDArgs *rdargs,
 525             UBYTE **errstrp, struct CSource *res, ULONG flags)
 526 {
 527   LONG retval;
 528   IPTR Args[NDBARGS] = { 0 };
 529   struct HostentNode *hn;
 530   struct in_addr addr;
 531   int aliases;
 532
 533 #if defined(__AROS__)
 534 D(bug("[AROSTCP](amiga_netdb.c) addhostent()\n"));
 535 #endif
 536
 537   if (rdargs = ReadArgs(NETDBTEMPLATE, Args, rdargs)) {
 538     /* convert ip address */
 539     if (__inet_aton((char*)Args[KNDB_NAME], &addr)) {
 540       hn = node_alloc(sizeof (*hn) + 2*sizeof (&addr) + sizeof (addr),
 541                       (UBYTE*)Args[KNDB_DATA],
 542                       (UBYTE **)Args[KNDB_ALIAS], &aliases);
 543       if (hn) {
 544         struct in_addr **addrtbl = (struct in_addr **)(hn + 1);
 545         UBYTE **alias = (UBYTE **)((UBYTE*)(addrtbl + 2) + sizeof (addr));
 546         UBYTE *name = (UBYTE *)(alias + aliases);
 547
 548         hn->hn_Ent.h_addrtype = AF_INET;
 549         hn->hn_Ent.h_length = sizeof (addr);
 550         hn->hn_Ent.h_addr_list = (char **)addrtbl;
 551         hn->hn_Ent.h_name = name;
 552         hn->hn_Ent.h_aliases = (char **)alias;
 553
 554         /* Make address list */
 555         addrtbl[0] = (struct in_addr *)(addrtbl + 2);
 556         addrtbl[1] = NULL;
 557         bcopy(&addr, addrtbl[0], sizeof (addr));
 558
 559         /* Copy aliases */
 560         aliascpy(hn->hn_Ent.h_name, (UBYTE*)Args[KNDB_DATA],
 561                  alias, (UBYTE **)Args[KNDB_ALIAS]);
 562         AddTail((struct List*)&ndb->ndb_Hosts, (struct Node*)hn);
 563         retval = RETURN_OK;
 564       } else {
 565         *errstrp = ERR_MEMORY; retval = RETURN_FAIL;
 566       }
 567     } else {
 568       *errstrp = ERR_VALUE; retval = RETURN_WARN;
 569     }
 570     FreeArgs(rdargs);
 571   } else {
 572     *errstrp = ERR_SYNTAX; retval = RETURN_WARN;
 573   }
 574   return retval;
 575 }
 576
 577 /*
 578  * Parse a net entry.
 579  */
 580 LONG
 581 addnetent(struct NetDataBase *ndb,
 582           struct RDArgs *rdargs,
 583           UBYTE **errstrp, struct CSource *res, ULONG flags)
 584 {
 585   LONG retval;
 586   IPTR Args[NDBARGS] = { 0 };
 587   struct NetentNode *nn;
 588   struct in_addr addr;
 589   int aliases;
 590
 591 #if defined(__AROS__)
 592 D(bug("[AROSTCP](amiga_netdb.c) addnetent()\n"));
 593 #endif
 594
 595   if (rdargs = ReadArgs(NETDBTEMPLATE, Args, rdargs)) {
 596     /* convert ip address */
 597     if (__inet_aton((char*)Args[KNDB_DATA], &addr)) {
 598       nn = node_alloc(sizeof (*nn),
 599                       (UBYTE*)Args[KNDB_NAME],
 600                       (UBYTE **)Args[KNDB_ALIAS], &aliases);
 601       if (nn) {
 602         UBYTE **alias = (UBYTE **)(nn + 1);
 603         UBYTE *name = (UBYTE *)(alias + aliases);
 604
 605         nn->nn_Ent.n_addrtype = AF_INET;
 606         nn->nn_Ent.n_name = name;
 607         nn->nn_Ent.n_aliases = (char **)alias;
 608         bcopy(&addr, &nn->nn_Ent.n_net, sizeof (addr));
 609
 610         /* Copy aliases */
 611         aliascpy(nn->nn_Ent.n_name, (UBYTE*)Args[KNDB_NAME],
 612                  alias, (UBYTE **)Args[KNDB_ALIAS]);
 613         AddTail((struct List*)&ndb->ndb_Networks, (struct Node*)nn);
 614         retval = RETURN_OK;
 615       } else {
 616         *errstrp = ERR_MEMORY; retval = RETURN_FAIL;
 617       }
 618     } else {
 619       *errstrp = ERR_VALUE; retval = RETURN_WARN;
 620     }
 621     FreeArgs(rdargs);
 622   } else {
 623     *errstrp = ERR_SYNTAX; retval = RETURN_WARN;
 624   }
 625   return retval;
 626 }
 627
 628 /*
 629  * Parse a protocol entry.
 630  */
 631 LONG
 632 addprotoent(struct NetDataBase *ndb,
 633             struct RDArgs *rdargs,
 634             UBYTE **errstrp, struct CSource *res, ULONG flags)
 635 {
 636   LONG retval;
 637   IPTR Args[NDBARGS] = { 0 };
 638   struct ProtoentNode *pn;
 639   int aliases;
 640
 641 #if defined(__AROS__)
 642 D(bug("[AROSTCP](amiga_netdb.c) addprotoent()\n"));
 643 #endif
 644
 645   if (rdargs = ReadArgs(PROTOCOL_TEMPLATE, Args, rdargs)) {
 646
 647     if (Args[KNDB_DATA]) {
 648       pn = node_alloc(sizeof (*pn), (UBYTE*)Args[KNDB_NAME],
 649                       (UBYTE **)Args[KNDB_ALIAS], &aliases);
 650       if (pn) {
 651         UBYTE **alias = (UBYTE **)(pn+1);
 652         UBYTE *name = (UBYTE *)(alias + aliases);
 653
 654         pn->pn_Ent.p_name = name;
 655         pn->pn_Ent.p_aliases = (char **)alias;
 656         pn->pn_Ent.p_proto = *(LONG *)Args[KNDB_DATA];
 657
 658         /* Copy name and aliases */
 659         aliascpy(name, (UBYTE*)Args[KNDB_NAME],
 660                  alias, (UBYTE **)Args[KNDB_ALIAS]);
 661         AddTail((struct List*)&ndb->ndb_Protocols, (struct Node*)pn);
 662         retval = RETURN_OK;
 663       } else {
 664         *errstrp = ERR_MEMORY; retval = RETURN_FAIL;
 665       }
 666     } else {
 667       *errstrp = ERR_VALUE; retval = RETURN_WARN;
 668     }
 669     FreeArgs(rdargs);
 670   } else {
 671     *errstrp = ERR_SYNTAX; retval = RETURN_WARN;
 672   }
 673   return retval;
 674 }
 675
 676 /*
 677  * Parse a route entry
 678  */
 679 LONG
 680 addrtent(struct NetDataBase *ndb,
 681                struct RDArgs *rdargs,
 682                UBYTE **errstrp, struct CSource *res, ULONG flags)
 683 {
 684   LONG retval;
 685   IPTR Args[RTARGS] = { 0 };
 686   struct ortentry route;
 687
 688 #if defined(__AROS__)
 689 D(bug("[AROSTCP](amiga_netdb.c) addrtent()\n"));
 690 #endif
 691
 692   if (rdargs = ReadArgs(ROUTE_TEMPLATE, Args, rdargs)) {
 693     if (!(strcmp(strupr((APTR)Args[KRT_DEST]), "DEFAULT"))){
 694       struct sockaddr_in *rodst_saddr = (struct sockaddr_in *)&route.rt_dst;
 695       rodst_saddr->sin_addr.s_addr = 0;
 696       route.rt_dst.sa_family = AF_INET;
 697       route.rt_dst.sa_len = sizeof(struct sockaddr_in);
 698     } else {
 699       if (!(setaddr((struct sockaddr_in *)&route.rt_dst, (APTR)Args[KRT_DEST], AF_INET)))
 700         goto bad;
 701     }
 702
 703     if (setaddr((struct sockaddr_in *)&route.rt_gateway, (APTR)Args[KRT_GATE], AF_INET)) {
 704       route.rt_flags = RTF_UP | RTF_GATEWAY;
 705       if (Args[KRT_HOST])
 706         route.rt_flags |= RTF_HOST;
 707       rtioctl(SIOCADDRT, (caddr_t)&route);
 708       retval = RETURN_OK;
 709     } else {
 710 bad:
 711       *errstrp = ERR_SYNTAX;
 712       retval = RETURN_WARN;
 713     }
 714     FreeArgs(rdargs);
 715   }
 716   return retval;
 717 }
 718
 719 /*
 720  * Parse a Name Server entry
 721  */
 722 LONG
 723 addnameservent(struct NetDataBase *ndb,
 724                struct RDArgs *rdargs,
 725                UBYTE **errstrp, struct CSource *res, ULONG flags)
 726 {
 727   UBYTE Buffer[KEYWORDLEN];
 728   LONG  BufLen = sizeof (Buffer);
 729   struct in_addr ns_addr;
 730   struct NameserventNode *nsn;
 731
 732 #if defined(__AROS__)
 733 D(bug("[AROSTCP](amiga_netdb.c) addnameservent()\n"));
 734 #endif
 735
 736 /* TODO: NicJA - Where does CHECK_POINTER() Come from? */
 737 #if !defined(__AROS__)
 738   CHECK_POINTER(ndb);
 739 #endif
 740
 741   if (ReadItem(Buffer, BufLen, &rdargs->RDA_Source) <= 0) {
 742 #if defined(__AROS__)
 743 D(bug("[AROSTCP](amiga_netdb.c) addnameservent: Error in syntax\n"));
 744 #endif
 745     *errstrp = ERR_SYNTAX;
 746     return RETURN_WARN;
 747   }
 748   if (!__inet_aton(Buffer, &ns_addr)) {
 749 #if defined(__AROS__)
 750 D(bug("[AROSTCP](amiga_netdb.c) addnameservent: error with address\n"));
 751 #endif
 752     *errstrp = ERR_VALUE;
 753     return RETURN_WARN;
 754   }
 755   if ((nsn = bsd_malloc(sizeof (*nsn), M_NETDB, M_WAITOK)) == NULL) {
 756 #if defined(__AROS__)
 757 D(bug("[AROSTCP](amiga_netdb.c) addnameservent: couldnt allocate entry\n"));
 758 #endif
 759     *errstrp = ERR_MEMORY;
 760     return RETURN_FAIL;
 761   }
 762   nsn->nsn_EntSize = sizeof (nsn->nsn_Ent);
 763   nsn->nsn_Ent.ns_addr.s_addr = ns_addr.s_addr;
 764
 765 /* TODO: NicJA - Where does CHECK_POINTER() Come from? */
 766 #if !defined(__AROS__)
 767   CHECK_POINTER(nsn);
 768 #endif
 769
 770 #if defined(__AROS__)
 771 D(bug("[AROSTCP](amiga_netdb.c) addnameservent: Added nameserver %s (0x%08lx) to netdb = 0x%08lx\n",Buffer, nsn->nsn_Ent.ns_addr.s_addr, ndb));
 772 #endif
 773   DNETDB(__log(LOG_DEBUG,"Added nameserver %s (0x%08lx) to netdb = 0x%08lx\n",Buffer, nsn->nsn_Ent.ns_addr.s_addr, ndb);)
 774
 775   AddTail((struct List*)&ndb->ndb_NameServers, (struct Node*)nsn);
 776   return RETURN_OK;
 777 }
 778
 779 /*
 780  * Parse a Domain Name entry
 781  */
 782 LONG
 783 adddomainent(struct NetDataBase *ndb,
 784                struct RDArgs *rdargs,
 785                UBYTE **errstrp, struct CSource *res, ULONG flags)
 786 {
 787   UBYTE Buffer[REPLYBUFLEN];
 788   LONG  BufLen = sizeof (Buffer);
 789   struct DomainentNode *dn;
 790   short  nodesize;
 791
 792 #if defined(__AROS__)
 793 D(bug("[AROSTCP](amiga_netdb.c) adddomainent()\n"));
 794 #endif
 795
 796   if (ReadItem(Buffer, BufLen, &rdargs->RDA_Source) <= 0) {
 797     *errstrp = ERR_SYNTAX;
 798     return RETURN_WARN;
 799   }
 800   nodesize = sizeof (*dn) + strlen(Buffer) + 1;
 801   if ((dn = bsd_malloc(nodesize, M_NETDB, M_WAITOK)) == NULL) {
 802     *errstrp = ERR_MEMORY;
 803     return RETURN_FAIL;
 804   }
 805   dn->dn_EntSize = nodesize - sizeof (struct GenentNode);
 806   dn->dn_Ent.d_name = (char *)(dn + 1);
 807
 808   strcpy((char *)(dn + 1), Buffer);
 809
 810   AddTail((struct List*)&ndb->ndb_Domains, (struct Node*)dn);
 811   return RETURN_OK;
 812 }
 813
 814 /*
 815  * Parse an RC script entry
 816  */
 817 LONG
 818 addrcent(struct NetDataBase *ndb,
 819                struct RDArgs *rdargs,
 820                UBYTE **errstrp, struct CSource *res, ULONG flags)
 821 {
 822   UBYTE Buffer[REPLYBUFLEN];
 823   LONG  BufLen = sizeof (Buffer);
 824   struct RcentNode *dn;
 825   short  nodesize;
 826
 827 #if defined(__AROS__)
 828 D(bug("[AROSTCP](amiga_netdb.c) addrcent()\n"));
 829 #endif
 830
 831   if (ReadItem(Buffer, BufLen, &rdargs->RDA_Source) <= 0) {
 832     *errstrp = ERR_SYNTAX;
 833     return RETURN_WARN;
 834   }
 835   nodesize = sizeof (*dn) + strlen(Buffer) + 1;
 836   if ((dn = bsd_malloc(nodesize, M_NETDB, M_WAITOK)) == NULL) {
 837     *errstrp = ERR_MEMORY;
 838     return RETURN_FAIL;
 839   }
 840   dn->rn_EntSize = nodesize - sizeof (struct GenentNode);
 841   dn->rn_Ent = (char *)(dn + 1);
 842
 843   strcpy((char *)(dn + 1), Buffer);
 844
 845   AddTail((struct List*)&ndb->ndb_Rc, (struct Node*)dn);
 846   return RETURN_OK;
 847 }
 848
 849
 850 /*
 851  * Parse a access control entry.. after reading the whole netdatabase
 852  * access list must be reorganized;
 853  */
 854 LONG
 855 addaccessent(struct NetDataBase *ndb,
 856              struct RDArgs *rdargs,
 857              UBYTE **errstrp, struct CSource *res, ULONG ifflags)
 858 {
 859   LONG retval = RETURN_WARN;
 860   IPTR Args[ACCARGS] = { 0 };
 861
 862   ULONG host, mask;
 863   UWORD port, flags = ACF_CONTINUE;
 864
 865 #if defined(__AROS__)
 866 D(bug("[AROSTCP](amiga_netdb.c) addaccessent()\n"));
 867 #endif
 868
 869   if (ndb->ndb_AccessCount >= TMPACTSIZE / sizeof (struct AccessItem)) {
 870     *errstrp = "Too many access control items\n";
 871     return retval; /* copy propagation expected */
 872   }
 873
 874   if ((rdargs = ReadArgs(ACCESS_TEMPLATE, Args, rdargs)) != NULL) {
 875
 876     if (strcmp((char *)Args[KACC_PORT], "*") == 0)
 877       port = 0;
 878     else if (strcmp((char *)Args[KACC_PORT], "@") == 0) {
 879       port = 0; flags |= ACF_PRIVONLY;
 880     }
 881     else if (StrToLong((char *)Args[KACC_PORT], (LONG *)&host) > 0
 882              && host != 0) {
 883       if (host > 0xffff) {
 884         *errstrp = "Illegal port value\n";
 885         goto exit;
 886       }
 887       port = host;
 888     }
 889     else {
 890       struct ServentNode * entNode;
 891
 892       if ((entNode =
 893            findServentNode(ndb, (char *)Args[KACC_PORT], "tcp")) != NULL)
 894           port = entNode->sn_Ent.s_port;
 895       else {
 896         *errstrp = "Illegal port value\n";
 897         goto exit;
 898       }
 899     }
 900     {
 901       int zmask = 0xFFFFFFFF;
 902       int i = 0, ls = 0, dots = 0;
 903
 904 #define hm ((char *)Args[KACC_HOSTMASK])
 905
 906       while ((hm[i] >= '0' && hm[i] <= '9') || hm[i] == '.' || hm[i] == '*') {
 907         if (hm[i] == '.') {
 908           ls = 0;
 909           dots++;
 910         }
 911         else if (hm[i] == '*') {
 912           hm[i] = '0';
 913           ls = 1;
 914           zmask ^= (0xFF000000 >> 8 * dots);
 915         }
 916         i++;
 917       }
 918       if (ls == 1)
 919         while (dots++ < 3)
 920           zmask ^= (0xFF000000 >> 8 * dots);
 921
 922       if (hm[i] == '/') {
 923         hm[i++] = '\0';
 924         if (__inet_aton(&hm[i], (struct in_addr *)&mask) == 0) {
 925           *errstrp = "Illegal mask value\n";
 926           goto exit;
 927         }
 928       }
 929       else
 930         mask = 0xffffffff;
 931
 932       mask &= zmask;
 933
 934       if (__inet_aton(hm, (struct in_addr *)&host) == 0) {
 935         *errstrp = "Illegal host value\n";
 936         goto exit;
 937       }
 938 #undef hm
 939     }
 940     if (strcmp((char *)Args[KACC_ACCESS], "allow") == 0)
 941       flags |= ACF_ALLOW;
 942     else if (strcmp((char *)Args[KACC_ACCESS], "deny") != 0) {
 943       *errstrp = "Illegal access value\n";
 944       goto exit;
 945     }
 946
 947     if (Args[KACC_LOG])
 948       flags |= ACF_LOG;
 949
 950     ndb->ndb_AccessTable[ndb->ndb_AccessCount].ai_port = port;
 951     ndb->ndb_AccessTable[ndb->ndb_AccessCount].ai_host = host;
 952     ndb->ndb_AccessTable[ndb->ndb_AccessCount].ai_mask = mask;
 953     ndb->ndb_AccessTable[ndb->ndb_AccessCount].ai_flags = flags;
 954     ndb->ndb_AccessCount++;
 955
 956     retval = 0;
 957   exit:
 958     FreeArgs(rdargs);
 959   }
 960   else
 961     *errstrp = ERR_SYNTAX;
 962
 963   return retval;
 964 }
 965
 966 /*
 967  * Add an entry into NetDB.
 968  * Caller must have a write lock on ndb
 969  */
 970 LONG
 971 addndbent(struct NetDataBase *ndb,
 972           struct RDArgs *rdargs,
 973           UBYTE **errstrp, struct CSource *res, ULONG flags)
 974 {
 975   if (NDB) {
 976     LONG item;
 977     enum ndbtype which;
 978     UBYTE Buffer[KEYWORDLEN];
 979
 980 #if defined(__AROS__)
 981 D(bug("[AROSTCP](amiga_netdb.c) addndbent()\n"));
 982 #endif
 983
 984     /* Get entry type */
 985     item = ReadItem(Buffer, sizeof (Buffer), &rdargs->RDA_Source);
 986
 987     if (item == 0)
 988       return RETURN_OK;         /* empty line */
 989     if (item < 0) {
 990       DNETDB(Printf("addndbent: syntax error\n");)
 991       *errstrp = ERR_SYNTAX;
 992       return RETURN_WARN;
 993     }
 994     if ((which = FindArg(NETDBENTRY, Buffer)) < 0) {
 995       DNETDB(Printf("Unknown keyword\n");)
 996       *errstrp = ERR_UNKNOWN;
 997       return RETURN_WARN;
 998     }
 999
1000     DNETDB(Printf("Keyword number: %ld\n", which);)
1001     which =  ndb_parse_funs[which](ndb, rdargs, errstrp, res, flags);
1002     return which;
1003
1004   } else {
1005     *errstrp = ERR_NONETDB;
1006     return RETURN_FAIL;
1007   }
1008 }
1009
1010 /*
1011  * Read in a NetDataBase file
1012  */
1013 LONG
1014 read_netdb(struct NetDataBase *ndb, UBYTE *fname,
1015            UBYTE** errstrp, struct CSource *res, int prefixindex, ULONG flags)
1016 {
1017   LONG warnval = RETURN_OK;
1018   LONG retval = RETURN_OK, ioerr = 0;
1019   UBYTE *p, *buf = AllocMem(CONFIGLINELEN, MEMF_PUBLIC);
1020   struct RDArgs *rdargs;
1021   BPTR fh;
1022   short line = 0;
1023   ndb_parse_f parser;
1024   BPTR lock, oldcd;
1025
1026 #if defined(__AROS__)
1027 D(bug("[AROSTCP](amiga_netdb.c) read_netdb('%s')\n", fname));
1028 #endif
1029
1030   DNETDB(Printf("Reading netdb file: %s\n", fname);)
1031   /* Get an exclusive lock on the database.
1032    * Multiple locks are OK (when this function is called recursively)
1033    */
1034   LOCK_W_NDB(ndb);
1035   if (ndb_Lock.ss_NestCount > 10) {
1036     UNLOCK_NDB(ndb);
1037     *errstrp = "Too many files included";
1038 #if defined(__AROS__)
1039 D(bug("[AROSTCP](amiga_netdb.c) read_netdb: Too many files included\n"));
1040 #endif
1041     return RETURN_ERROR;
1042   }
1043   if (buf) {
1044
1045     /* CD to netdb directory */
1046     lock = Lock(db_path, ACCESS_READ);
1047     if (lock)
1048       oldcd = CurrentDir(lock);
1049
1050     if (fh = Open(fname, MODE_OLDFILE)) {
1051       if (rdargs = AllocDosObject(DOS_RDARGS, NULL)) {
1052         /* initialize CSource of the rdargs */
1053         rdargs->RDA_Source.CS_Buffer = buf;
1054         /* initialize rest fields (see dos/rdargs.h) */
1055         rdargs->RDA_DAList = 0;
1056         rdargs->RDA_ExtHelp = NULL;
1057         rdargs->RDA_Flags = 0;
1058
1059         if (prefixindex < 0)
1060           parser = addndbent;   /* no prefix */
1061         else
1062           parser = ndb_parse_funs[prefixindex];
1063
1064         while (FGets(fh, buf, CONFIGLINELEN - 1)) {
1065           line++;               /* maintain line number */
1066           /* pass by white space */
1067           for (p = buf; *p == ' ' || *p == '\t' || *p == '\r'; p++)
1068             ;
1069           rdargs->RDA_Source.CS_CurChr = p - buf;
1070           if (*p == '#' || *p == ';' || *p == '\n') /* only a comment line */
1071             continue;
1072           /* remove comments & calc length */
1073           for (; *p; p++) {
1074             if (*p == '#' || *p == ';') {
1075               *p++ = '\n';
1076               *p   = '\0';      /* terminate line */
1077               break;
1078             }
1079           }
1080           /* ensure that line ends with '\n' (ReadArgs() depends on it) */
1081           if (*(p - 1) != '\n') {
1082             *p++ = '\n';
1083             *p   = '\0';
1084           }
1085           rdargs->RDA_Source.CS_Length = p - buf;
1086           rdargs->RDA_Buffer = NULL;
1087           rdargs->RDA_BufSiz = 0;
1088 #if defined(__AROS__)
1089 D(bug("[AROSTCP](amiga_netdb.c) read_netdb: parsing line: %s, prefixindex=%ld\n", buf, prefixindex));
1090 #endif
1091           DNETDB(Printf("Processing line: %s, prefixindex=%ld\n", buf, prefixindex);)
1092           retval = parser(ndb, rdargs, errstrp, res, flags);
1093           if (retval == RETURN_OK)
1094             continue;
1095           if (retval != RETURN_WARN) { /* severe error */
1096             error_request("Fatal error in NetDB file %s at line %ld, col %ld\n%s\nAROSTCP will quit",
1097                 (IPTR)fname, (IPTR)line, (IPTR)rdargs->RDA_Source.CS_CurChr, (IPTR)*errstrp);
1098             break;
1099           }
1100           /* Log the error */
1101           error_request("Error in NetDB file %s at line %ld, col %ld\n%s",
1102                 (IPTR)fname, (IPTR)line, (IPTR)rdargs->RDA_Source.CS_CurChr, (IPTR)*errstrp);
1103           __log(LOG_WARNING, "NetDB(%s) line %ld: %s before col %ld\n",
1104               fname, line, *errstrp, rdargs->RDA_Source.CS_CurChr);
1105
1106           warnval = retval;
1107         }
1108         /* Check file error */
1109         ioerr = IoErr();
1110
1111         FreeDosObject(DOS_RDARGS, rdargs);
1112       }
1113       Close(fh);
1114     } else {
1115       ioerr = IoErr();
1116     }
1117
1118     if (ioerr) {
1119 #if defined(__AROS__)
1120 D(bug("[AROSTCP](amiga_netdb.c) read_netdb: ioerror\n"));
1121 #endif
1122       Fault(ioerr, "readnetdb", res->CS_Buffer, res->CS_Length);
1123       *errstrp = res->CS_Buffer;
1124       retval = RETURN_ERROR;
1125     }
1126     if ((!fh) && (ndb_Lock.ss_NestCount == 1))
1127         error_request("Unable to open NetDB file %s\n%s", (IPTR)fname, (IPTR)*errstrp);
1128
1129     /* return old current directory */
1130     if (lock) {
1131       CurrentDir(oldcd);
1132       UnLock(lock);
1133     }
1134
1135     FreeMem(buf, CONFIGLINELEN);
1136   } else {
1137 #if defined(__AROS__)
1138 D(bug("[AROSTCP](amiga_netdb.c) read_netdb: Failed to allocate buffer\n"));
1139 #endif
1140     *errstrp = ERR_MEMORY;
1141     retval = RETURN_FAIL;
1142   }
1143
1144   UNLOCK_NDB(ndb);
1145
1146   return retval > warnval? retval: warnval;
1147 }
1148
1149 /*
1150  * Parse the 'ADD' command
1151  */
1152 LONG
1153 do_netdb(struct CSource *csarg, UBYTE **errstrp, struct CSource *res)
1154 {
1155   struct RDArgs *rdargs;
1156   LONG retval;
1157
1158 #if defined(__AROS__)
1159 D(bug("[AROSTCP](amiga_netdb.c) do_netdb()\n"));
1160 #endif
1161
1162   if (rdargs = AllocDosObject(DOS_RDARGS, NULL)) {
1163     /* initialize CSource of the rdargs */
1164     rdargs->RDA_Source = *csarg;
1165     /* initialize rest fields (see <dos/rdargs.h>) */
1166     rdargs->RDA_DAList = 0;
1167     rdargs->RDA_Buffer = NULL;
1168     rdargs->RDA_BufSiz = 0;
1169     rdargs->RDA_ExtHelp = NULL;
1170     rdargs->RDA_Flags = 0;
1171
1172     LOCK_W_NDB(NDB);
1173
1174     retval = addndbent(NDB, rdargs, errstrp, res, 0);
1175 /* TODO: set flags here */
1176
1177     UNLOCK_NDB(NDB);
1178
1179     FreeDosObject(DOS_RDARGS, rdargs);
1180   }
1181   else
1182     retval = RETURN_FAIL;
1183
1184   return retval;
1185 }
1186
1187 /*
1188  * Initialize the Network Data Base
1189  */
1190 LONG
1191 init_netdb(void)
1192 {
1193   UBYTE result[REPLYBUFLEN + 1]; /* for error returns */
1194   struct CSource res;
1195   UBYTE *errstr;
1196   LONG   retval;
1197
1198 #if defined(__AROS__)
1199 D(bug("[AROSTCP](amiga_netdb.c) init_netdb()\n"));
1200 #endif
1201
1202   res.CS_Buffer = result;
1203   res.CS_Length = sizeof (result);
1204   res.CS_CurChr = 0;
1205
1206   InitSemaphore (&ndb_Lock);
1207   InitSemaphore (&DynDB.dyn_Lock);
1208   NewList((struct List *)&DynDB.dyn_NameServers);
1209   NewList((struct List *)&DynDB.dyn_Domains);
1210   ndb_Serial = 0;
1211
1212   /* Allocate the NetDataBase */
1213   if (!(NDB = alloc_netdb(NULL))) {
1214     return RETURN_FAIL;
1215   }
1216
1217   /* Read in the default data base file */
1218   retval = read_netdb(NDB, netdbname, &errstr, &res, -1, NETDB_IFF_ADDNEW);
1219 /*  if (retval) {
1220     Printf("init_netdb: file %s: %s\n", netdbname, errstr);
1221     __log(LOG_WARNING, "init_netdb: file %s: %s", netdbname, errstr);
1222   } else */
1223   if (retval == RETURN_WARN)
1224     retval = RETURN_OK;
1225
1226   if (!retval)
1227     setup_accesscontroltable(NDB);
1228
1229   return retval;
1230 }
1231
1232
1233 void netdb_deinit(void)
1234 {
1235 #if defined(__AROS__)
1236 D(bug("[AROSTCP](amiga_netdb.c) netdb_deinit()\n"));
1237 #endif
1238   /* A Placeholder for possible future deinitializations */
1239 }
1240
1241 /*
1242  * Reset the NetDataBase
1243  */
1244 LONG reset_netdb(struct CSource *cs,
1245                  UBYTE **errstrp,
1246                  struct CSource *res)
1247 {
1248   LONG retval;
1249   struct NetDataBase *newnetdb;
1250
1251 #if defined(__AROS__)
1252 D(bug("[AROSTCP](amiga_netdb.c) reset_netdb()\n"));
1253 #endif
1254
1255   /* Allocate a temporary NetDataBase */
1256   if (!(newnetdb = alloc_netdb(NULL))) {
1257     *errstrp = ERR_MEMORY;
1258     return RETURN_FAIL;
1259   }
1260
1261   retval = read_netdb(newnetdb, netdbname, errstrp, res, -1, 0);
1262 /* TODO: set flags here */
1263
1264   if (retval == RETURN_OK) {
1265     setup_accesscontroltable(newnetdb);
1266
1267     /* Now clear the old lists of the NDB */
1268     LOCK_W_NDB(NDB);
1269
1270     free_netdb(NDB);
1271     NDB = newnetdb;
1272
1273     UNLOCK_NDB(NDB);
1274     ndb_Serial++;
1275   } else {
1276     free_netdb(newnetdb);
1277   }
1278
1279   return retval;
1280 }
1281