int main(int argc, char **argv) { int reti; uint16_t vid; struct vol *vol; struct dir *retdir; struct path *path; /* initialize */ printf("Initializing\n============\n"); TEST(setuplog("default:note","/dev/tty")); TEST( afp_options_parse_cmdline(&obj, 3, &args[0]) ); TEST_int( afp_config_parse(&obj, NULL), 0); TEST_int( configinit(&obj), 0); TEST( cnid_init() ); TEST( load_volumes(&obj, NULL) ); TEST_int( dircache_init(8192), 0); obj.afp_version = 32; printf("\n"); /* now run tests */ printf("Running tests\n=============\n"); TEST_expr(vid = openvol(&obj, "test"), vid != 0); TEST_expr(vol = getvolbyvid(vid), vol != NULL); /* test directory.c stuff */ TEST_expr(retdir = dirlookup(vol, DIRDID_ROOT_PARENT), retdir != NULL); TEST_expr(retdir = dirlookup(vol, DIRDID_ROOT), retdir != NULL); TEST_expr(path = cname(vol, retdir, cnamewrap("Network Trash Folder")), path != NULL); TEST_expr(retdir = dirlookup(vol, DIRDID_ROOT), retdir != NULL); TEST_int(getfiledirparms(&obj, vid, DIRDID_ROOT_PARENT, "test"), 0); TEST_int(getfiledirparms(&obj, vid, DIRDID_ROOT, ""), 0); TEST_expr(reti = createdir(&obj, vid, DIRDID_ROOT, "dir1"), reti == 0 || reti == AFPERR_EXIST); TEST_int(getfiledirparms(&obj, vid, DIRDID_ROOT, "dir1"), 0); /* FIXME: this doesn't work although it should. "//" get translated to \000 \000 at means ".." ie this should getfiledirparms for DIRDID_ROOT_PARENT -- at least afair! TEST_int(getfiledirparms(&configs->obj, vid, DIRDID_ROOT, "//"), 0); */ TEST_int(createfile(&obj, vid, DIRDID_ROOT, "dir1/file1"), 0); TEST_int(delete(&obj, vid, DIRDID_ROOT, "dir1/file1"), 0); TEST_int(delete(&obj, vid, DIRDID_ROOT, "dir1"), 0); TEST_int(createfile(&obj, vid, DIRDID_ROOT, "file1"), 0); TEST_int(getfiledirparms(&obj, vid, DIRDID_ROOT, "file1"), 0); TEST_int(delete(&obj, vid, DIRDID_ROOT, "file1"), 0); /* test enumerate.c stuff */ TEST_int(enumerate(&obj, vid, DIRDID_ROOT), 0); }
void load_all_volumes(string_table & tbl,std::vector<grids>& all_volumes,int selected) { all_volumes.resize(selected); for(int i=0;i<selected;i++) { all_volumes[i].resize(tbl[0].size()-1); load_volumes(tbl[i+1],all_volumes[i]); } }
void load_all_volumes_0(string_table & tbl,std::vector<volumes>& all_volumes,int selected,bool verbose) { all_volumes.resize(selected); for(int i=0;i<selected;i++) { all_volumes[i].resize(tbl[0].size()); load_volumes(tbl[i],all_volumes[i],0,verbose); } }
int main(int argc, char **argv) { AFPObj obj = { 0 }; if (argc < 2) { usage_main(); return 1; } if (afp_config_parse(&obj, "ad") != 0) return 1; setuplog("default:note", "/dev/tty"); if (load_volumes(&obj, LV_DEFAULT) != 0) return 1; if (STRCMP(argv[1], ==, "ls")) return ad_ls(argc - 1, argv + 1, &obj); else if (STRCMP(argv[1], ==, "cp"))
/* ------------------------------------------- afp over dsi. this never returns. */ void afp_over_dsi(AFPObj *obj) { DSI *dsi = (DSI *) obj->handle; int rc_idx; u_int32_t err, cmd; u_int8_t function; AFPobj = obj; obj->exit = afp_dsi_die; obj->reply = (int (*)()) dsi_cmdreply; obj->attention = (int (*)(void *, AFPUserBytes)) dsi_attention; dsi->tickle = 0; afp_over_dsi_sighandlers(obj); if (dircache_init(obj->options.dircachesize) != 0) afp_dsi_die(EXITERR_SYS); /* set TCP snd/rcv buf */ if (obj->options.tcp_rcvbuf) { if (setsockopt(dsi->socket, SOL_SOCKET, SO_RCVBUF, &obj->options.tcp_rcvbuf, sizeof(obj->options.tcp_rcvbuf)) != 0) { LOG(log_error, logtype_dsi, "afp_over_dsi: setsockopt(SO_RCVBUF): %s", strerror(errno)); } } if (obj->options.tcp_sndbuf) { if (setsockopt(dsi->socket, SOL_SOCKET, SO_SNDBUF, &obj->options.tcp_sndbuf, sizeof(obj->options.tcp_sndbuf)) != 0) { LOG(log_error, logtype_dsi, "afp_over_dsi: setsockopt(SO_SNDBUF): %s", strerror(errno)); } } /* set TCP_NODELAY */ int flag = 1; setsockopt(dsi->socket, SOL_TCP, TCP_NODELAY, &flag, sizeof(flag)); /* get stuck here until the end */ while (1) { if (sigsetjmp(recon_jmp, 1) != 0) /* returning from SIGALARM handler for a primary reconnect */ continue; /* Blocking read on the network socket */ cmd = dsi_stream_receive(dsi); if (cmd == 0) { /* cmd == 0 is the error condition */ if (dsi->flags & DSI_RECONSOCKET) { /* we just got a reconnect so we immediately try again to receive on the new fd */ dsi->flags &= ~DSI_RECONSOCKET; continue; } /* the client sometimes logs out (afp_logout) but doesn't close the DSI session */ if (dsi->flags & DSI_AFP_LOGGED_OUT) { LOG(log_note, logtype_afpd, "afp_over_dsi: client logged out, terminating DSI session"); afp_dsi_close(obj); exit(0); } #if 0 /* got ECONNRESET in read from client => exit*/ if (dsi->flags & DSI_GOT_ECONNRESET) { LOG(log_note, logtype_afpd, "afp_over_dsi: client connection reset"); afp_dsi_close(obj); exit(0); } #endif if (dsi->flags & DSI_RECONINPROG) { LOG(log_note, logtype_afpd, "afp_over_dsi: failed reconnect"); afp_dsi_close(obj); exit(0); } /* Some error on the client connection, enter disconnected state */ if (dsi_disconnect(dsi) != 0) afp_dsi_die(EXITERR_CLNT); while (dsi->flags & DSI_DISCONNECTED) pause(); /* gets interrupted by SIGALARM or SIGURG tickle */ continue; /* continue receiving until disconnect timer expires * or a primary reconnect succeeds */ } if (!(dsi->flags & DSI_EXTSLEEP) && (dsi->flags & DSI_SLEEPING)) { LOG(log_debug, logtype_afpd, "afp_over_dsi: got data, ending normal sleep"); dsi->flags &= ~DSI_SLEEPING; dsi->tickle = 0; } if (reload_request) { reload_request = 0; load_volumes(AFPobj); } /* The first SIGINT enables debugging, the next restores the config */ if (debug_request) { static int debugging = 0; debug_request = 0; dircache_dump(); uuidcache_dump(); if (debugging) { if (obj->options.logconfig) setuplog(obj->options.logconfig); else setuplog("default log_note"); debugging = 0; } else { char logstr[50]; debugging = 1; sprintf(logstr, "default log_maxdebug /tmp/afpd.%u.XXXXXX", getpid()); setuplog(logstr); } } dsi->flags |= DSI_DATA; dsi->tickle = 0; switch(cmd) { case DSIFUNC_CLOSE: LOG(log_debug, logtype_afpd, "DSI: close session request"); afp_dsi_close(obj); LOG(log_note, logtype_afpd, "done"); exit(0); case DSIFUNC_TICKLE: dsi->flags &= ~DSI_DATA; /* thats no data in the sense we use it in alarm_handler */ LOG(log_debug, logtype_afpd, "DSI: client tickle"); /* timer is not every 30 seconds anymore, so we don't get killed on the client side. */ if ((dsi->flags & DSI_DIE)) dsi_tickle(dsi); break; case DSIFUNC_CMD: #ifdef AFS if ( writtenfork ) { if ( flushfork( writtenfork ) < 0 ) { LOG(log_error, logtype_afpd, "main flushfork: %s", strerror(errno) ); } writtenfork = NULL; } #endif /* AFS */ function = (u_char) dsi->commands[0]; /* AFP replay cache */ rc_idx = dsi->clientID % REPLAYCACHE_SIZE; LOG(log_debug, logtype_dsi, "DSI request ID: %u", dsi->clientID); if (replaycache[rc_idx].DSIreqID == dsi->clientID && replaycache[rc_idx].AFPcommand == function) { LOG(log_note, logtype_afpd, "AFP Replay Cache match: id: %u / cmd: %s", dsi->clientID, AfpNum2name(function)); err = replaycache[rc_idx].result; /* AFP replay cache end */ } else { /* send off an afp command. in a couple cases, we take advantage * of the fact that we're a stream-based protocol. */ if (afp_switch[function]) { dsi->datalen = DSI_DATASIZ; dsi->flags |= DSI_RUNNING; LOG(log_debug, logtype_afpd, "<== Start AFP command: %s", AfpNum2name(function)); err = (*afp_switch[function])(obj, (char *)&dsi->commands, dsi->cmdlen, (char *)&dsi->data, &dsi->datalen); LOG(log_debug, logtype_afpd, "==> Finished AFP command: %s -> %s", AfpNum2name(function), AfpErr2name(err)); dir_free_invalid_q(); #ifdef FORCE_UIDGID /* bring everything back to old euid, egid */ if (obj->force_uid) restore_uidgid ( &obj->uidgid ); #endif /* FORCE_UIDGID */ dsi->flags &= ~DSI_RUNNING; /* Add result to the AFP replay cache */ replaycache[rc_idx].DSIreqID = dsi->clientID; replaycache[rc_idx].AFPcommand = function; replaycache[rc_idx].result = err; } else { LOG(log_error, logtype_afpd, "bad function %X", function); dsi->datalen = 0; err = AFPERR_NOOP; } } /* single shot toggle that gets set by dsi_readinit. */ if (dsi->flags & DSI_NOREPLY) { dsi->flags &= ~DSI_NOREPLY; break; } else if (!dsi_cmdreply(dsi, err)) { LOG(log_error, logtype_afpd, "dsi_cmdreply(%d): %s", dsi->socket, strerror(errno) ); if (dsi_disconnect(dsi) != 0) afp_dsi_die(EXITERR_CLNT); } break; case DSIFUNC_WRITE: /* FPWrite and FPAddIcon */ function = (u_char) dsi->commands[0]; if ( afp_switch[ function ] != NULL ) { dsi->datalen = DSI_DATASIZ; dsi->flags |= DSI_RUNNING; LOG(log_debug, logtype_afpd, "<== Start AFP command: %s", AfpNum2name(function)); err = (*afp_switch[function])(obj, (char *)&dsi->commands, dsi->cmdlen, (char *)&dsi->data, &dsi->datalen); LOG(log_debug, logtype_afpd, "==> Finished AFP command: %s -> %s", AfpNum2name(function), AfpErr2name(err)); dsi->flags &= ~DSI_RUNNING; #ifdef FORCE_UIDGID /* bring everything back to old euid, egid */ if (obj->force_uid) restore_uidgid ( &obj->uidgid ); #endif /* FORCE_UIDGID */ } else { LOG(log_error, logtype_afpd, "(write) bad function %x", function); dsi->datalen = 0; err = AFPERR_NOOP; } if (!dsi_wrtreply(dsi, err)) { LOG(log_error, logtype_afpd, "dsi_wrtreply: %s", strerror(errno) ); if (dsi_disconnect(dsi) != 0) afp_dsi_die(EXITERR_CLNT); } break; case DSIFUNC_ATTN: /* attention replies */ break; /* error. this usually implies a mismatch of some kind * between server and client. if things are correct, * we need to flush the rest of the packet if necessary. */ default: LOG(log_info, logtype_afpd,"afp_dsi: spurious command %d", cmd); dsi_writeinit(dsi, dsi->data, DSI_DATASIZ); dsi_writeflush(dsi); break; } pending_request(dsi); fce_pending_events(obj); } /* error */ afp_dsi_die(EXITERR_CLNT); }
int main(int argc, char **argv) { int c, lockfd, ret = -1; int dump=0, scan=0, rebuild=0, prep_upgrade=0, rebuildindexes=0, dumpindexes=0, force=0; dbd_flags_t flags = 0; char *volpath; int cdir; AFPObj obj = { 0 }; struct vol *vol; if (geteuid() != 0) { usage(); exit(EXIT_FAILURE); } /* Inhereting perms in ad_mkdir etc requires this */ ad_setfuid(0); while ((c = getopt(argc, argv, ":cCdefFinrstuvx")) != -1) { switch(c) { case 'c': flags |= DBD_FLAGS_CLEANUP; break; case 'C': flags |= DBD_FLAGS_V2TOEA; break; case 'd': dump = 1; break; case 'i': dumpindexes = 1; break; case 's': scan = 1; flags |= DBD_FLAGS_SCAN; break; case 'n': nocniddb = 1; /* FIXME: this could/should be a flag too for consistency */ break; case 'r': rebuild = 1; break; case 't': flags |= DBD_FLAGS_STATS; break; case 'u': prep_upgrade = 1; break; case 'v': verbose = 1; break; case 'e': exclusive = 1; flags |= DBD_FLAGS_EXCL; break; case 'x': rebuildindexes = 1; break; case 'f': force = 1; exclusive = 1; flags |= DBD_FLAGS_FORCE | DBD_FLAGS_EXCL; break; case 'F': obj.cmdlineconfigfile = strdup(optarg); break; case ':': case '?': usage(); exit(EXIT_FAILURE); break; } } if ((dump + scan + rebuild + prep_upgrade) != 1) { usage(); exit(EXIT_FAILURE); } if ( (optind + 1) != argc ) { usage(); exit(EXIT_FAILURE); } volpath = argv[optind]; setvbuf(stdout, (char *) NULL, _IONBF, 0); /* Remember cwd */ if ((cdir = open(".", O_RDONLY)) < 0) { dbd_log( LOGSTD, "Can't open dir: %s", strerror(errno)); exit(EXIT_FAILURE); } /* Setup signal handling */ set_signal(); /* Setup logging. Should be portable among *NIXes */ if (!verbose) setuplog("default:info", "/dev/tty"); else setuplog("default:debug", "/dev/tty"); /* Load config */ if (afp_config_parse(&obj, "dbd") != 0) { dbd_log( LOGSTD, "Couldn't load afp.conf"); exit(EXIT_FAILURE); } if (load_volumes(&obj, NULL) != 0) { dbd_log( LOGSTD, "Couldn't load volumes"); exit(EXIT_FAILURE); } if ((vol = getvolbypath(&obj, volpath)) == NULL) { dbd_log( LOGSTD, "Couldn't find volume for '%s'", volpath); exit(EXIT_FAILURE); } if (load_charset(vol) != 0) { dbd_log( LOGSTD, "Couldn't load charsets for '%s'", volpath); exit(EXIT_FAILURE); } pack_setvol(vol); if (vol->v_adouble == AD_VERSION_EA) dbd_log( LOGDEBUG, "adouble:ea volume"); else if (vol->v_adouble == AD_VERSION2) dbd_log( LOGDEBUG, "adouble:v2 volume"); else { dbd_log( LOGSTD, "unknown adouble volume"); exit(EXIT_FAILURE); } /* -C v2 to ea conversion only on adouble:ea volumes */ if ((flags & DBD_FLAGS_V2TOEA) && (vol->v_adouble!= AD_VERSION_EA)) { dbd_log( LOGSTD, "Can't run adouble:v2 to adouble:ea conversion because not an adouble:ea volume"); exit(EXIT_FAILURE); } /* Sanity checks to ensure we can touch this volume */ if (vol->v_vfs_ea != AFPVOL_EA_AD && vol->v_vfs_ea != AFPVOL_EA_SYS) { dbd_log( LOGSTD, "Unknown Extended Attributes option: %u", vol->v_vfs_ea); exit(EXIT_FAILURE); } /* Enuser dbpath is there, create if necessary */ struct stat st; if (stat(vol->v_dbpath, &st) != 0) { if (errno != ENOENT) { dbd_log( LOGSTD, "Can't stat dbpath \"%s\": %s", vol->v_dbpath, strerror(errno)); exit(EXIT_FAILURE); } if ((mkdir(vol->v_dbpath, 0755)) != 0) { dbd_log( LOGSTD, "Can't create dbpath \"%s\": %s", vol->v_dbpath, strerror(errno)); exit(EXIT_FAILURE); } } /* Put "/.AppleDB" at end of volpath, get path from volinfo file */ if ( (strlen(vol->v_dbpath) + strlen("/.AppleDB")) > MAXPATHLEN ) { dbd_log( LOGSTD, "Volume pathname too long"); exit(EXIT_FAILURE); } strncpy(dbpath, vol->v_dbpath, MAXPATHLEN - strlen("/.AppleDB")); strcat(dbpath, "/.AppleDB"); /* Check or create dbpath */ int dbdirfd = open(dbpath, O_RDONLY); if (dbdirfd == -1 && errno == ENOENT) { if (errno == ENOENT) { if ((mkdir(dbpath, 0755)) != 0) { dbd_log( LOGSTD, "Can't create .AppleDB for \"%s\": %s", dbpath, strerror(errno)); exit(EXIT_FAILURE); } } else { dbd_log( LOGSTD, "Somethings wrong with .AppleDB for \"%s\", giving up: %s", dbpath, strerror(errno)); exit(EXIT_FAILURE); } } else { close(dbdirfd); } /* Get db lock */ if ((db_locked = get_lock(LOCK_EXCL, dbpath)) == -1) goto exit_noenv; if (db_locked != LOCK_EXCL) { /* Couldn't get exclusive lock, try shared lock if -e wasn't requested */ if (exclusive) { dbd_log(LOGSTD, "Database is in use and exlusive was requested"); goto exit_noenv; } if ((db_locked = get_lock(LOCK_SHRD, NULL)) != LOCK_SHRD) goto exit_noenv; } /* Check if -f is requested and wipe db if yes */ if ((flags & DBD_FLAGS_FORCE) && rebuild) { char cmd[8 + MAXPATHLEN]; if ((db_locked = get_lock(LOCK_FREE, NULL)) != 0) goto exit_noenv; snprintf(cmd, 8 + MAXPATHLEN, "rm -rf \"%s\"", dbpath); dbd_log( LOGDEBUG, "Removing old database of volume: '%s'", volpath); system(cmd); if ((mkdir(dbpath, 0755)) != 0) { dbd_log( LOGSTD, "Can't create dbpath \"%s\": %s", dbpath, strerror(errno)); exit(EXIT_FAILURE); } dbd_log( LOGDEBUG, "Removed old database."); if ((db_locked = get_lock(LOCK_EXCL, dbpath)) == -1) goto exit_noenv; } /* Lets start with the BerkeleyDB stuff */ if ( ! nocniddb) { if ((dbd = dbif_init(dbpath, "cnid2.db")) == NULL) goto exit_noenv; if (dbif_env_open(dbd, &db_param, (db_locked == LOCK_EXCL) ? (DBOPTIONS | DB_RECOVER) : DBOPTIONS) < 0) { dbd_log( LOGSTD, "error opening database!"); goto exit_noenv; } if (db_locked == LOCK_EXCL) dbd_log( LOGDEBUG, "Finished recovery."); if (dbif_open(dbd, NULL, rebuildindexes) < 0) { dbif_close(dbd); goto exit_failure; } /* Prepare upgrade ? We're done */ if (prep_upgrade) { (void)dbif_txn_close(dbd, 1); goto cleanup; } } /* Downgrade db lock if not running exclusive */ if (!exclusive && (db_locked == LOCK_EXCL)) { if (get_lock(LOCK_UNLOCK, NULL) != 0) goto exit_failure; if (get_lock(LOCK_SHRD, NULL) != LOCK_SHRD) goto exit_failure; } /* Now execute given command scan|rebuild|dump */ if (dump && ! nocniddb) { if (dbif_dump(dbd, dumpindexes) < 0) { dbd_log( LOGSTD, "Error dumping database"); } } else if ((rebuild && ! nocniddb) || scan) { if (cmd_dbd_scanvol(dbd, vol, flags) < 0) { dbd_log( LOGSTD, "Error repairing database."); } } cleanup: /* Cleanup */ dbd_log(LOGDEBUG, "Closing db"); if (! nocniddb) { if (dbif_close(dbd) < 0) { dbd_log( LOGSTD, "Error closing database"); goto exit_failure; } } exit_success: ret = 0; exit_failure: if (dbif_env_remove(dbpath) < 0) { dbd_log( LOGSTD, "Error removing BerkeleyDB database environment"); ret++; } get_lock(0, NULL); exit_noenv: if ((fchdir(cdir)) < 0) dbd_log(LOGSTD, "fchdir: %s", strerror(errno)); if (ret == 0) exit(EXIT_SUCCESS); else exit(EXIT_FAILURE); }