etc/afpd/afp_config.c

   1 /*
   2  * Copyright (c) 1997 Adrian Sun (asun@zoology.washington.edu)
   3  * All Rights Reserved.  See COPYRIGHT.
   4  */
   5
   6 #ifdef HAVE_CONFIG_H
   7 #include "config.h"
   8 #endif /* HAVE_CONFIG_H */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <errno.h>
  14 #include <string.h>
  15 #include <unistd.h>
  16 #include <ctype.h>
  17 #include <sys/socket.h>
  18 #include <netinet/in.h>
  19 #include <arpa/inet.h>
  20
  21 #ifdef USE_SRVLOC
  22 #include <slp.h>
  23 #endif /* USE_SRVLOC */
  24
  25 #include <atalk/logger.h>
  26 #include <atalk/util.h>
  27 #include <atalk/dsi.h>
  28 #include <atalk/atp.h>
  29 #include <atalk/asp.h>
  30 #include <atalk/nbp.h>
  31 #include <atalk/afp.h>
  32 #include <atalk/compat.h>
  33 #include <atalk/server_child.h>
  34
  35 #ifdef HAVE_LDAP
  36 #include <atalk/ldapconfig.h>
  37 #endif
  38
  39 #include "globals.h"
  40 #include "afp_config.h"
  41 #include "uam_auth.h"
  42 #include "status.h"
  43 #include "volume.h"
  44 #include "afp_zeroconf.h"
  45
  46 #define LINESIZE 1024
  47
  48 /* get rid of unneeded configurations. i use reference counts to deal
  49  * w/ multiple configs sharing the same afp_options. oh, to dream of
  50  * garbage collection ... */
  51 void configfree(AFPConfig *configs, const AFPConfig *config)
  52 {
  53     AFPConfig *p, *q;
  54
  55     for (p = configs; p; p = q) {
  56         q = p->next;
  57         if (p == config)
  58             continue;
  59
  60         /* do a little reference counting */
  61         if (--(*p->optcount) < 1) {
  62             afp_options_free(&p->obj.options, p->defoptions);
  63             free(p->optcount);
  64         }
  65
  66         switch (p->obj.proto) {
  67 #ifndef NO_DDP
  68         case AFPPROTO_ASP:
  69             free(p->obj.Obj);
  70             free(p->obj.Type);
  71             free(p->obj.Zone);
  72             atp_close(((ASP) p->obj.handle)->asp_atp);
  73             free(p->obj.handle);
  74             break;
  75 #endif /* no afp/asp */
  76         case AFPPROTO_DSI:
  77             close(p->fd);
  78             free(p->obj.handle);
  79             break;
  80         }
  81         free(p);
  82     }
  83
  84     /* the master loaded the volumes for zeroconf, get rid of that */
  85     unload_volumes_and_extmap();
  86 }
  87
  88 #ifdef USE_SRVLOC
  89 static void SRVLOC_callback(SLPHandle hslp _U_, SLPError errcode, void *cookie) {
  90     *(SLPError*)cookie = errcode;
  91 }
  92
  93 static char hex[17] = "0123456789abcdef";
  94
  95 static char * srvloc_encode(const struct afp_options *options, const char *name)
  96 {
  97         static char buf[512];
  98         char *conv_name;
  99         unsigned char *p;
 100         unsigned int i = 0;
 101 #ifndef NO_DDP
 102         char *Obj, *Type = "", *Zone = "";
 103 #endif
 104
 105         /* Convert name to maccharset */
 106         if ((size_t)-1 ==(convert_string_allocate( options->unixcharset, options->maccharset,
 107                          name, -1, &conv_name)) )
 108                 return (char*)name;
 109
 110         /* Escape characters */
 111         p = conv_name;
 112         while (*p && i<(sizeof(buf)-4)) {
 113             if (*p == '@')
 114                 break;
 115             else if (isspace(*p)) {
 116                 buf[i++] = '%';
 117                 buf[i++] = '2';
 118                 buf[i++] = '0';
 119                 p++;
 120             }
 121             else if ((!isascii(*p)) || *p <= 0x2f || *p == 0x3f ) {
 122                 buf[i++] = '%';
 123                 buf[i++] = hex[*p >> 4];
 124                 buf[i++] = hex[*p++ & 15];
 125             }
 126             else {
 127                 buf[i++] = *p++;
 128             }
 129         }
 130         buf[i] = '\0';
 131
 132 #ifndef NO_DDP
 133         /* Add ZONE,  */
 134         if (nbp_name(options->server, &Obj, &Type, &Zone )) {
 135                 LOG(log_error, logtype_afpd, "srvloc_encode: can't parse %s", options->server );
 136         }
 137         else {
 138                 snprintf( buf+i, sizeof(buf)-i-1 ,"&ZONE=%s", Zone);
 139         }
 140 #endif
 141         free (conv_name);
 142
 143         return buf;
 144 }
 145 #endif /* USE_SRVLOC */
 146
 147 static void dsi_cleanup(const AFPConfig *config)
 148 {
 149 #ifdef USE_SRVLOC
 150     SLPError err;
 151     SLPError callbackerr;
 152     SLPHandle hslp;
 153     DSI *dsi = (DSI *)config->obj.handle;
 154
 155     /*  Do nothing if we didn't register.  */
 156     if (!dsi || dsi->srvloc_url[0] == '\0')
 157         return;
 158
 159     err = SLPOpen("en", SLP_FALSE, &hslp);
 160     if (err != SLP_OK) {
 161         LOG(log_error, logtype_afpd, "dsi_cleanup: Error opening SRVLOC handle");
 162         goto srvloc_dereg_err;
 163     }
 164
 165     err = SLPDereg(hslp,
 166                    dsi->srvloc_url,
 167                    SRVLOC_callback,
 168                    &callbackerr);
 169     if (err != SLP_OK) {
 170         LOG(log_error, logtype_afpd, "dsi_cleanup: Error unregistering %s from SRVLOC", dsi->srvloc_url);
 171         goto srvloc_dereg_err;
 172     }
 173
 174     if (callbackerr != SLP_OK) {
 175         LOG(log_error, logtype_afpd, "dsi_cleanup: Error in callback while trying to unregister %s from SRVLOC (%d)", dsi->srvloc_url, callbackerr);
 176         goto srvloc_dereg_err;
 177     }
 178
 179 srvloc_dereg_err:
 180     dsi->srvloc_url[0] = '\0';
 181     SLPClose(hslp);
 182 #endif /* USE_SRVLOC */
 183 }
 184
 185 #ifndef NO_DDP
 186 static void asp_cleanup(const AFPConfig *config)
 187 {
 188     /* we need to stop tickle handler */
 189     asp_stop_tickle();
 190     nbp_unrgstr(config->obj.Obj, config->obj.Type, config->obj.Zone,
 191                 &config->obj.options.ddpaddr);
 192 }
 193
 194 /* these two are almost identical. it should be possible to collapse them
 195  * into one with minimal junk. */
 196 static int asp_start(AFPConfig *config, AFPConfig *configs,
 197                      server_child *server_children)
 198 {
 199     ASP asp;
 200
 201     if (!(asp = asp_getsession(config->obj.handle, server_children,
 202                                config->obj.options.tickleval))) {
 203         LOG(log_error, logtype_afpd, "main: asp_getsession: %s", strerror(errno) );
 204         exit( EXITERR_CLNT );
 205     }
 206
 207     if (asp->child) {
 208         configfree(configs, config); /* free a bunch of stuff */
 209         afp_over_asp(&config->obj);
 210         exit (0);
 211     }
 212
 213     return 0;
 214 }
 215 #endif /* no afp/asp */
 216
 217 static afp_child_t *dsi_start(AFPConfig *config, AFPConfig *configs,
 218                               server_child *server_children)
 219 {
 220     DSI *dsi = config->obj.handle;
 221     afp_child_t *child = NULL;
 222
 223     if (!(child = dsi_getsession(dsi,
 224                                  server_children,
 225                                  config->obj.options.tickleval))) {
 226         LOG(log_error, logtype_afpd, "dsi_start: session error: %s", strerror(errno));
 227         return NULL;
 228     }
 229
 230     /* we've forked. */
 231     if (parent_or_child == 1) {
 232         configfree(configs, config);
 233         config->obj.ipc_fd = child->ipc_fds[1];
 234         close(child->ipc_fds[0]); /* Close parent IPC fd */
 235         free(child);
 236         afp_over_dsi(&config->obj); /* start a session */
 237         exit (0);
 238     }
 239
 240     return child;
 241 }
 242
 243 #ifndef NO_DDP
 244 static AFPConfig *ASPConfigInit(const struct afp_options *options,
 245                                 unsigned char *refcount)
 246 {
 247     AFPConfig *config;
 248     ATP atp;
 249     ASP asp;
 250     char *Obj, *Type = "AFPServer", *Zone = "*";
 251     char *convname = NULL;
 252
 253     if ((config = (AFPConfig *) calloc(1, sizeof(AFPConfig))) == NULL)
 254         return NULL;
 255
 256     if ((atp = atp_open(ATADDR_ANYPORT, &options->ddpaddr)) == NULL)  {
 257         LOG(log_error, logtype_afpd, "main: atp_open: %s", strerror(errno) );
 258         free(config);
 259         return NULL;
 260     }
 261
 262     if ((asp = asp_init( atp )) == NULL) {
 263         LOG(log_error, logtype_afpd, "main: asp_init: %s", strerror(errno) );
 264         atp_close(atp);
 265         free(config);
 266         return NULL;
 267     }
 268
 269     /* register asp server */
 270     Obj = (char *) options->hostname;
 271     if (options->server && (size_t)-1 ==(convert_string_allocate( options->unixcharset, options->maccharset,
 272                          options->server, strlen(options->server), &convname)) ) {
 273         if ((convname = strdup(options->server)) == NULL ) {
 274             LOG(log_error, logtype_afpd, "malloc: %s", strerror(errno) );
 275             goto serv_free_return;
 276         }
 277     }
 278
 279     if (nbp_name(convname, &Obj, &Type, &Zone )) {
 280         LOG(log_error, logtype_afpd, "main: can't parse %s", options->server );
 281         goto serv_free_return;
 282     }
 283     if (convname)
 284         free (convname);
 285
 286     /* dup Obj, Type and Zone as they get assigned to a single internal
 287      * buffer by nbp_name */
 288     if ((config->obj.Obj  = strdup(Obj)) == NULL)
 289         goto serv_free_return;
 290
 291     if ((config->obj.Type = strdup(Type)) == NULL) {
 292         free(config->obj.Obj);
 293         goto serv_free_return;
 294     }
 295
 296     if ((config->obj.Zone = strdup(Zone)) == NULL) {
 297         free(config->obj.Obj);
 298         free(config->obj.Type);
 299         goto serv_free_return;
 300     }
 301
 302     /* make sure we're not registered */
 303     nbp_unrgstr(Obj, Type, Zone, &options->ddpaddr);
 304     if (nbp_rgstr( atp_sockaddr( atp ), Obj, Type, Zone ) < 0 ) {
 305         LOG(log_error, logtype_afpd, "Can't register %s:%s@%s", Obj, Type, Zone );
 306         free(config->obj.Obj);
 307         free(config->obj.Type);
 308         free(config->obj.Zone);
 309         goto serv_free_return;
 310     }
 311
 312     LOG(log_info, logtype_afpd, "%s:%s@%s started on %u.%u:%u (%s)", Obj, Type, Zone,
 313         ntohs( atp_sockaddr( atp )->sat_addr.s_net ),
 314         atp_sockaddr( atp )->sat_addr.s_node,
 315         atp_sockaddr( atp )->sat_port, VERSION );
 316
 317     config->fd = atp_fileno(atp);
 318     config->obj.handle = asp;
 319     config->obj.config = config;
 320     config->obj.proto = AFPPROTO_ASP;
 321
 322     memcpy(&config->obj.options, options, sizeof(struct afp_options));
 323     config->optcount = refcount;
 324     (*refcount)++;
 325
 326     config->server_start = asp_start;
 327     config->server_cleanup = asp_cleanup;
 328
 329     return config;
 330
 331 serv_free_return:
 332                     asp_close(asp);
 333     free(config);
 334     return NULL;
 335 }
 336 #endif /* no afp/asp */
 337
 338
 339 static AFPConfig *DSIConfigInit(const struct afp_options *options,
 340                                 unsigned char *refcount,
 341                                 const dsi_proto protocol)
 342 {
 343     AFPConfig *config;
 344     DSI *dsi;
 345     char *p, *q;
 346
 347     if ((config = (AFPConfig *) calloc(1, sizeof(AFPConfig))) == NULL) {
 348         LOG(log_error, logtype_afpd, "DSIConfigInit: malloc(config): %s", strerror(errno) );
 349         return NULL;
 350     }
 351
 352     LOG(log_debug, logtype_afpd, "DSIConfigInit: hostname: %s, ip/port: %s/%s, ",
 353         options->hostname,
 354         options->ipaddr ? options->ipaddr : "default",
 355         options->port ? options->port : "548");
 356
 357     if ((dsi = dsi_init(protocol, "afpd", options->hostname,
 358                         options->ipaddr, options->port,
 359                         options->flags & OPTION_PROXY,
 360                         options->server_quantum)) == NULL) {
 361         LOG(log_error, logtype_afpd, "main: dsi_init: %s", strerror(errno) );
 362         free(config);
 363         return NULL;
 364     }
 365
 366     if (options->flags & OPTION_PROXY) {
 367         LOG(log_note, logtype_afpd, "AFP/TCP proxy initialized for %s:%d (%s)",
 368             getip_string((struct sockaddr *)&dsi->server), getip_port((struct sockaddr *)&dsi->server), VERSION);
 369     } else {
 370         LOG(log_note, logtype_afpd, "AFP/TCP started, advertising %s:%d (%s)",
 371             getip_string((struct sockaddr *)&dsi->server), getip_port((struct sockaddr *)&dsi->server), VERSION);
 372     }
 373
 374 #ifdef USE_SRVLOC
 375     dsi->srvloc_url[0] = '\0';  /*  Mark that we haven't registered.  */
 376     if (!(options->flags & OPTION_NOSLP)) {
 377         SLPError err;
 378         SLPError callbackerr;
 379         SLPHandle hslp;
 380         unsigned int afp_port;
 381         int   l;
 382         char *srvloc_hostname;
 383         const char *hostname;
 384
 385         err = SLPOpen("en", SLP_FALSE, &hslp);
 386         if (err != SLP_OK) {
 387             LOG(log_error, logtype_afpd, "DSIConfigInit: Error opening SRVLOC handle");
 388             goto srvloc_reg_err;
 389         }
 390
 391         /* XXX We don't want to tack on the port number if we don't have to.
 392          * Why?
 393          * Well, this seems to break MacOS < 10.  If the user _really_ wants to
 394          * use a non-default port, they can, but be aware, this server might
 395          * not show up int the Network Browser.
 396          */
 397         afp_port = getip_port((struct sockaddr *)&dsi->server);
 398         /* If specified use the FQDN to register with srvloc, otherwise use IP. */
 399         p = NULL;
 400         if (options->fqdn) {
 401             hostname = options->fqdn;
 402             p = strchr(hostname, ':');
 403         }
 404         else
 405             hostname = getip_string((struct sockaddr *)&dsi->server);
 406
 407         srvloc_hostname = srvloc_encode(options, (options->server ? options->server : options->hostname));
 408
 409         if ((p) || afp_port == 548) {
 410             l = snprintf(dsi->srvloc_url, sizeof(dsi->srvloc_url), "afp://%s/?NAME=%s", hostname, srvloc_hostname);
 411         }
 412         else {
 413             l = snprintf(dsi->srvloc_url, sizeof(dsi->srvloc_url), "afp://%s:%d/?NAME=%s", hostname, afp_port, srvloc_hostname);
 414         }
 415
 416         if (l == -1 || l >= (int)sizeof(dsi->srvloc_url)) {
 417             LOG(log_error, logtype_afpd, "DSIConfigInit: Hostname is too long for SRVLOC");
 418             dsi->srvloc_url[0] = '\0';
 419             goto srvloc_reg_err;
 420         }
 421
 422         err = SLPReg(hslp,
 423                      dsi->srvloc_url,
 424                      SLP_LIFETIME_MAXIMUM,
 425                      "afp",
 426                      "",
 427                      SLP_TRUE,
 428                      SRVLOC_callback,
 429                      &callbackerr);
 430         if (err != SLP_OK) {
 431             LOG(log_error, logtype_afpd, "DSIConfigInit: Error registering %s with SRVLOC", dsi->srvloc_url);
 432             dsi->srvloc_url[0] = '\0';
 433             goto srvloc_reg_err;
 434         }
 435
 436         if (callbackerr != SLP_OK) {
 437             LOG(log_error, logtype_afpd, "DSIConfigInit: Error in callback trying to register %s with SRVLOC", dsi->srvloc_url);
 438             dsi->srvloc_url[0] = '\0';
 439             goto srvloc_reg_err;
 440         }
 441
 442         LOG(log_info, logtype_afpd, "Sucessfully registered %s with SRVLOC", dsi->srvloc_url);
 443         config->server_cleanup = dsi_cleanup;
 444
 445 srvloc_reg_err:
 446         SLPClose(hslp);
 447     }
 448 #endif /* USE_SRVLOC */
 449
 450     config->fd = dsi->serversock;
 451     config->obj.handle = dsi;
 452     config->obj.config = config;
 453     config->obj.proto = AFPPROTO_DSI;
 454
 455     memcpy(&config->obj.options, options, sizeof(struct afp_options));
 456     /* get rid of any appletalk info. we use the fact that the DSI
 457      * stuff is done after the ASP stuff. */
 458     p = config->obj.options.server;
 459     if (p && (q = strchr(p, ':')))
 460         *q = '\0';
 461
 462     config->optcount = refcount;
 463     (*refcount)++;
 464
 465     config->server_start = dsi_start;
 466     return config;
 467 }
 468
 469 /* allocate server configurations. this should really store the last
 470  * entry in config->last or something like that. that would make
 471  * supporting multiple dsi transports easier. */
 472 static AFPConfig *AFPConfigInit(struct afp_options *options,
 473                                 const struct afp_options *defoptions)
 474 {
 475     AFPConfig *config = NULL, *next = NULL;
 476     unsigned char *refcount;
 477
 478     if ((refcount = (unsigned char *)
 479                     calloc(1, sizeof(unsigned char))) == NULL) {
 480         LOG(log_error, logtype_afpd, "AFPConfigInit: calloc(refcount): %s", strerror(errno) );
 481         return NULL;
 482     }
 483
 484 #ifndef NO_DDP
 485     /* handle asp transports */
 486     if ((options->transports & AFPTRANS_DDP) &&
 487             (config = ASPConfigInit(options, refcount)))
 488         config->defoptions = defoptions;
 489 #endif /* NO_DDP */
 490
 491
 492     /* set signature */
 493     set_signature(options);
 494
 495     /* handle dsi transports and dsi proxies. we only proxy
 496      * for DSI connections. */
 497
 498     /* this should have something like the following:
 499      * for (i=mindsi; i < maxdsi; i++)
 500      *   if (options->transports & (1 << i) &&
 501      *     (next = DSIConfigInit(options, refcount, i)))
 502      *     next->defoptions = defoptions;
 503      */
 504     if ((options->transports & AFPTRANS_TCP) &&
 505             (((options->flags & OPTION_PROXY) == 0) ||
 506              ((options->flags & OPTION_PROXY) && config))
 507             && (next = DSIConfigInit(options, refcount, DSI_TCPIP)))
 508         next->defoptions = defoptions;
 509
 510     /* load in all the authentication modules. we can load the same
 511        things multiple times if necessary. however, loading different
 512        things with the same names will cause complaints. by not loading
 513        in any uams with proxies, we prevent ddp connections from succeeding.
 514     */
 515     auth_load(options->uampath, options->uamlist);
 516
 517     /* this should be able to accept multiple dsi transports. i think
 518      * the only thing that gets affected is the net addresses. */
 519     status_init(config, next, options);
 520
 521     /* attach dsi config to tail of asp config */
 522     if (config) {
 523         config->next = next;
 524         return config;
 525     }
 526
 527     return next;
 528 }
 529
 530 /* fill in the appropriate bits for each interface */
 531 AFPConfig *configinit(struct afp_options *cmdline)
 532 {
 533     FILE *fp;
 534     char buf[LINESIZE + 1], *p, have_option = 0;
 535     size_t len;
 536     struct afp_options options;
 537     AFPConfig *config=NULL, *first = NULL;
 538
 539     /* if config file doesn't exist, load defaults */
 540     if ((fp = fopen(cmdline->configfile, "r")) == NULL)
 541     {
 542         LOG(log_debug, logtype_afpd, "ConfigFile %s not found, assuming defaults",
 543             cmdline->configfile);
 544         return AFPConfigInit(cmdline, cmdline);
 545     }
 546
 547     /* scan in the configuration file */
 548     len = 0;
 549     while (!feof(fp)) {
 550         if (!fgets(&buf[len], LINESIZE - len, fp) || buf[len] == '#')
 551             continue;
 552         len = strlen(buf);
 553         if ( len >= 2 && buf[len-2] == '\\' ) {
 554             len -= 2;
 555             continue;
 556         } else
 557             len = 0;
 558
 559         /* a little pre-processing to get rid of spaces and end-of-lines */
 560         p = buf;
 561         while (p && isspace(*p))
 562             p++;
 563         if (!p || (*p == '\0'))
 564             continue;
 565
 566         have_option = 1;
 567
 568         memcpy(&options, cmdline, sizeof(options));
 569         if (!afp_options_parseline(p, &options))
 570             continue;
 571
 572         /* AFPConfigInit can return two linked configs due to DSI and ASP */
 573         if (!first) {
 574             if ((first = AFPConfigInit(&options, cmdline)))
 575                 config = first->next ? first->next : first;
 576         } else if ((config->next = AFPConfigInit(&options, cmdline))) {
 577             config = config->next->next ? config->next->next : config->next;
 578         }
 579     }
 580
 581 #ifdef HAVE_LDAP
 582     /* Parse afp_ldap.conf */
 583     acl_ldap_readconfig(_PATH_ACL_LDAPCONF);
 584 #endif /* HAVE_LDAP */
 585
 586     LOG(log_debug, logtype_afpd, "Finished parsing Config File");
 587     fclose(fp);
 588
 589     if (!have_option)
 590         first = AFPConfigInit(cmdline, cmdline);
 591
 592     /* Now register with zeroconf, we also need the volumes for that */
 593     load_volumes(&first->obj);
 594     zeroconf_register(first);
 595
 596     return first;
 597 }