int main(int argc, char **argv) { char instance[PATH_MAX]; int ret; memset(instance, '\0', sizeof(instance)); log_init(LOG_WARN, LOG_OUT_STDOUT); cli_set_program_name(basename(argv[0])); if((argc > 2) && (strcmp(argv[1], "-i") == 0)){ strncpy(instance, argv[2], PATH_MAX - 1); argc -= 2; argv += 2; } else{ strncpy(instance, CLI_DEFAULT_INSTANCE, PATH_MAX - 1); } cli_init(instance); ret = cli_parse_args(argc, argv); if(ret < 0){ log_err("cannot execute."); } cli_close(); log_close(); return 0; }
static int /* O - 0 = success, non-0 = failure */ smb_print(struct cli_state *cli, /* I - SMB connection */ char *title, /* I - Title/job name */ FILE *fp) /* I - File to print */ { int fnum; /* File number */ int nbytes, /* Number of bytes read */ tbytes; /* Total bytes read */ char buffer[8192], /* Buffer for copy */ *ptr; /* Pointer into tile */ /* * Sanitize the title... */ for (ptr = title; *ptr; ptr ++) if (!isalnum((int)*ptr) && !isspace((int)*ptr)) *ptr = '_'; /* * Open the printer device... */ if ((fnum = cli_open(cli, title, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE)) == -1) { fprintf(stderr, "ERROR: %s opening remote spool %s\n", cli_errstr(cli), title); return (1); } /* * Copy the file to the printer... */ if (fp != stdin) rewind(fp); tbytes = 0; while ((nbytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) { if (cli_write(cli, fnum, 0, buffer, tbytes, nbytes) != nbytes) { fprintf(stderr, "ERROR: Error writing spool: %s\n", cli_errstr(cli)); break; } tbytes += nbytes; } if (!cli_close(cli, fnum)) { fprintf(stderr, "ERROR: %s closing remote spool %s\n", cli_errstr(cli), title); return (1); } else return (0); }
bool cli_rpc_pipe_close(struct rpc_pipe_client *cli) { bool ret; if (!cli) { return false; } ret = cli_close(cli->cli, cli->fnum); if (!ret) { DEBUG(1,("cli_rpc_pipe_close: cli_close failed on pipe %s, " "fnum 0x%x " "to machine %s. Error was %s\n", cli->pipe_name, (int) cli->fnum, cli->cli->desthost, cli_errstr(cli->cli))); } if (cli->auth.cli_auth_data_free_func) { (*cli->auth.cli_auth_data_free_func)(&cli->auth); } DEBUG(10,("cli_rpc_pipe_close: closed pipe %s to machine %s\n", cli->pipe_name, cli->cli->desthost )); DLIST_REMOVE(cli->cli->pipe_list, cli); talloc_destroy(cli->mem_ctx); return ret; }
static int tstream_cli_np_destructor(struct tstream_cli_np *cli_nps) { NTSTATUS status; if (!cli_state_is_connected(cli_nps->cli)) { return 0; } /* * TODO: do not use a sync call with a destructor!!! * * This only happens, if a caller does talloc_free(), * while the everything was still ok. * * If we get an unexpected failure within a normal * operation, we already do an async cli_close_send()/_recv(). * * Once we've fixed all callers to call * tstream_disconnect_send()/_recv(), this will * never be called. */ status = cli_close(cli_nps->cli, cli_nps->fnum); if (!NT_STATUS_IS_OK(status)) { DEBUG(1, ("tstream_cli_np_destructor: cli_close " "failed on pipe %s. Error was %s\n", cli_nps->npipe, nt_errstr(status))); } /* * We can't do much on failure */ return 0; }
NTSTATUS gpo_copy_file(TALLOC_CTX *mem_ctx, struct cli_state *cli, const char *nt_path, const char *unix_path) { NTSTATUS result; int fnum; int fd = 0; char *data = NULL; static int io_bufsize = 64512; int read_size = io_bufsize; off_t start = 0; off_t nread = 0; if ((fnum = cli_open(cli, nt_path, O_RDONLY, DENY_NONE)) == -1) { result = NT_STATUS_NO_SUCH_FILE; goto out; } if ((fd = sys_open(unix_path, O_WRONLY|O_CREAT|O_TRUNC, 0644)) == -1) { result = map_nt_error_from_unix(errno); goto out; } if ((data = (char *)SMB_MALLOC(read_size)) == NULL) { result = NT_STATUS_NO_MEMORY; goto out; } while (1) { int n = cli_read(cli, fnum, data, nread + start, read_size); if (n <= 0) break; if (write(fd, data, n) != n) { break; } nread += n; } result = NT_STATUS_OK; out: SAFE_FREE(data); if (fnum) { cli_close(cli, fnum); } if (fd) { close(fd); } return result; }
void nb_close(int handle) { int i; i = find_handle(handle); if (!NT_STATUS_IS_OK(cli_close(c, ftable[i].fd))) { printf("(%d) close failed on handle %d\n", line_count, handle); exit(1); } ftable[i].handle = 0; }
static void testpair(struct cli_state *cli1, struct cli_state *cli2, char *mask, char *file) { int fnum; fstring res1, res2; char *res3; static int count; count++; fstrcpy(res1, "---"); fstrcpy(res2, "---"); fnum = cli_open(cli1, file, O_CREAT|O_TRUNC|O_RDWR, 0); if (fnum == -1) { DEBUG(0,("Can't create %s on cli1\n", file)); return; } cli_close(cli1, fnum); fnum = cli_open(cli2, file, O_CREAT|O_TRUNC|O_RDWR, 0); if (fnum == -1) { DEBUG(0,("Can't create %s on cli2\n", file)); return; } cli_close(cli2, fnum); resultp = res1; cli_list(cli1, mask, aHIDDEN | aDIR, listfn); res3 = reg_test(mask, file); resultp = res2; cli_list(cli2, mask, aHIDDEN | aDIR, listfn); if (showall || strcmp(res1, res2)) { DEBUG(0,("%s %s %s %d mask=[%s] file=[%s]\n", res1, res2, res3, count, mask, file)); } cli_unlink(cli1, file); cli_unlink(cli2, file); }
int cli_init(const char *instance) { int ret; int flags; struct sockaddr_un saddr; if(instance == NULL){ log_err("instance must be specified."); return -1; } memset(cli_server_sock_file, '\0', sizeof(cli_server_sock_file)); snprintf(cli_server_sock_file, PATH_MAX - 1, "%s.%s", CMDIF_SERVER_SOCK_FILE, instance); memset(cli_client_sock_file, '\0', sizeof(cli_client_sock_file)); snprintf(cli_client_sock_file, PATH_MAX - 1, "%s.%s", CMDIF_CLIENT_SOCK_FILE, instance); if(cli_fd >= 0){ cli_close(); } cli_fd = socket(PF_UNIX, SOCK_DGRAM, 0); if(cli_fd < 0){ log_err("cannot create socket."); return -1; } memset(&saddr, 0, sizeof(saddr)); saddr.sun_family = AF_UNIX; strcpy(saddr.sun_path, cli_client_sock_file); unlink(cli_client_sock_file); ret = bind(cli_fd, (struct sockaddr *)&saddr, sizeof(saddr)); if(ret < 0){ log_err("cannot bind socket."); return -1; } flags = fcntl(cli_fd, F_GETFL); ret = fcntl(cli_fd, F_SETFL, O_NONBLOCK|flags); if(ret < 0){ log_err("cannot turn on non-blocking mode."); return -1; } srand(time(NULL)); return 0; }
void nb_close(int handle) { int i; for (i=0;i<MAX_FILES;i++) { if (ftable[i].handle == handle) break; } if (i == MAX_FILES) { printf("(%d) nb_close: handle %d was not open\n", line_count, handle); return; } cli_close(c, ftable[i].fd); ftable[i].handle = 0; }
int SMBC_close_ctx(SMBCCTX *context, SMBCFILE *file) { TALLOC_CTX *frame = talloc_stackframe(); if (!context || !context->internal->initialized) { errno = EINVAL; TALLOC_FREE(frame); return -1; } if (!file || !SMBC_dlist_contains(context->internal->files, file)) { errno = EBADF; TALLOC_FREE(frame); return -1; } /* IS a dir ... */ if (!file->file) { TALLOC_FREE(frame); return smbc_getFunctionClosedir(context)(context, file); } if (!NT_STATUS_IS_OK(cli_close(file->targetcli, file->cli_fd))) { SMBCSRV *srv; DEBUG(3, ("cli_close failed on %s. purging server.\n", file->fname)); /* Deallocate slot and remove the server * from the server cache if unused */ errno = SMBC_errno(context, file->targetcli); srv = file->srv; DLIST_REMOVE(context->internal->files, file); SAFE_FREE(file->fname); SAFE_FREE(file); smbc_getFunctionRemoveUnusedServer(context)(context, srv); TALLOC_FREE(frame); return -1; } DLIST_REMOVE(context->internal->files, file); SAFE_FREE(file->fname); SAFE_FREE(file); TALLOC_FREE(frame); return 0; }
static void close_files(struct cli_state *cli[NSERVERS][NCONNECTIONS], uint16_t fnum[NSERVERS][NCONNECTIONS][NFILES]) { int server, conn, f; for (server=0;server<NSERVERS;server++) for (conn=0;conn<NCONNECTIONS;conn++) for (f=0;f<NFILES;f++) { if (fnum[server][conn][f] != (uint16_t)-1) { cli_close(cli[server][conn], fnum[server][conn][f]); fnum[server][conn][f] = (uint16_t)-1; } } for (server=0;server<NSERVERS;server++) { cli_unlink(cli[server][0], FILENAME, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); } }
static void close_files(struct cli_state *cli[NSERVERS][NCONNECTIONS], int fnum[NSERVERS][NCONNECTIONS][NFILES]) { int server, conn, f; for (server=0;server<NSERVERS;server++) for (conn=0;conn<NCONNECTIONS;conn++) for (f=0;f<NFILES;f++) { if (fnum[server][conn][f] != -1) { cli_close(cli[server][conn], fnum[server][conn][f]); fnum[server][conn][f] = -1; } } for (server=0;server<NSERVERS;server++) { cli_unlink(cli[server][0], FILENAME); } }
static int rpc_transport_np_state_destructor(struct rpc_transport_np_state *s) { if (s->cli->fd == -1) { DEBUG(10, ("socket was closed, no need to send close request.\n")); return 0; } if (!NT_STATUS_IS_OK(cli_close(s->cli, s->fnum))) { DEBUG(1, ("rpc_transport_np_state_destructor: cli_close " "failed on pipe %s. Error was %s\n", s->pipe_name, cli_errstr(s->cli))); } DEBUG(10, ("rpc_pipe_destructor: closed %s\n", s->pipe_name)); /* * We can't do much on failure */ return 0; }
bool run_cleanup1(int dummy) { struct cli_state *cli; const char *fname = "\\cleanup1"; uint16_t fnum; NTSTATUS status; printf("CLEANUP1: Checking that a conflicting share mode is cleaned " "up\n"); if (!torture_open_connection(&cli, 0)) { return false; } status = cli_openx(cli, fname, O_RDWR|O_CREAT, DENY_ALL, &fnum); if (!NT_STATUS_IS_OK(status)) { printf("open of %s failed (%s)\n", fname, nt_errstr(status)); return false; } status = smbXcli_conn_samba_suicide(cli->conn, 1); if (!NT_STATUS_IS_OK(status)) { printf("smbXcli_conn_samba_suicide failed: %s\n", nt_errstr(status)); return false; } if (!torture_open_connection(&cli, 1)) { return false; } status = cli_ntcreate( cli, fname, 0, FILE_GENERIC_READ|FILE_GENERIC_WRITE|DELETE_ACCESS, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, FILE_OPEN, FILE_DELETE_ON_CLOSE, 0, &fnum, NULL); if (!NT_STATUS_IS_OK(status)) { printf("2nd open of %s failed (%s)\n", fname, nt_errstr(status)); return false; } cli_close(cli, fnum); torture_close_connection(cli); return NT_STATUS_IS_OK(status); }
/***************************************************** a wrapper for close() *******************************************************/ int smbw_close(int fd) { struct smbw_file *file; smbw_busy++; file = smbw_file(fd); if (!file) { int ret = smbw_dir_close(fd); smbw_busy--; return ret; } if (file->f->ref_count == 1 && !cli_close(&file->srv->cli, file->f->cli_fd)) { errno = smbw_errno(&file->srv->cli); smbw_busy--; return -1; } bitmap_clear(smbw_file_bmap, file->fd); close(file->fd); DLIST_REMOVE(smbw_files, file); file->f->ref_count--; if (file->f->ref_count == 0) { SAFE_FREE(file->f->fname); SAFE_FREE(file->f); } ZERO_STRUCTP(file); SAFE_FREE(file); smbw_busy--; return 0; }
static void reconnect(struct cli_state *cli[NSERVERS][NCONNECTIONS], uint16_t fnum[NSERVERS][NCONNECTIONS][NFILES], char *share[NSERVERS]) { int server, conn, f; for (server=0;server<NSERVERS;server++) for (conn=0;conn<NCONNECTIONS;conn++) { if (cli[server][conn]) { for (f=0;f<NFILES;f++) { if (fnum[server][conn][f] != (uint16_t)-1) { cli_close(cli[server][conn], fnum[server][conn][f]); fnum[server][conn][f] = (uint16_t)-1; } } cli_ulogoff(cli[server][conn]); cli_shutdown(cli[server][conn]); } cli[server][conn] = connect_one(share[server], server); if (!cli[server][conn]) { DEBUG(0,("Failed to connect to %s\n", share[server])); exit(1); } } }
int main() { char* databaseName = "testalter"; char* filePath = "testalter.fdb"; int i, rc; int session; int statement; cli_oid_t oid; foo f; alter_foo af; time_t start = time(NULL); session = cli_create(databaseName, filePath, 0, 0, 4*1024*1024, 4*1024*1024, 512*1024, 0); if (session < 0) { fprintf(stderr, "cli_open failed with code %d\n", session); return EXIT_FAILURE; } rc = cli_create_table(session, "foo", sizeof(foo_descriptor)/sizeof(cli_field_descriptor), foo_descriptor); if (rc != cli_ok) { fprintf(stderr, "cli_create_table failed with code %d\n", rc); return EXIT_FAILURE; } for (i = 0; i < N_RECORDS; i++) { char buf[32]; sprintf(buf, "%d", i); f.x = i; f.y = buf; f.z = i + (double)i / 10; rc = cli_insert_struct(session, "foo", &f, &oid); if (rc != cli_ok) { fprintf(stderr, "cli_insert failed with code %d\n", rc); return EXIT_FAILURE; } } printf("Elapsed time for inserting %d records: %d seconds\n", N_RECORDS, (int)(time(NULL) - start)); start = time(NULL); rc = cli_alter_table(session, "foo", sizeof(alter_foo_descriptor)/sizeof(cli_field_descriptor), alter_foo_descriptor); if (rc != cli_ok) { fprintf(stderr, "cli_alter_table failed with code %d\n", rc); return EXIT_FAILURE; } printf("Elapsed time for reformating %d records: %d seconds\n", N_RECORDS, (int)(time(NULL) - start)); start = time(NULL); statement = cli_prepare_query(session, "select * from foo where x=%i"); if (statement < 0) { fprintf(stderr, "cli_statement failed with code %d\n", rc); return EXIT_FAILURE; } for (i = 0; i < N_RECORDS; i++) { char buf[32]; sprintf(buf, "%d", i); rc = cli_execute_query(statement, cli_view_only, &af, i); if (rc != 1) { fprintf(stderr, "cli_execute_query failed with code %d\n", rc); return EXIT_FAILURE; } rc = cli_get_next(statement); if (rc != cli_ok) { fprintf(stderr, "cli_get_next failed with code %d\n", rc); return EXIT_FAILURE; } if (af.x != i || strcmp(buf, af.y) != 0 || *af.a != '\0' || (int)((af.z+0.01)*10) != i*10+i || af.b != 0) { fprintf(stderr, "Conversion error: i=%d, f.x=%ld, f.y=%s, f.a=%s, f.z=%f, f.b=%d\n", i, (long)af.x, af.y, af.a, af.z, af.b); return EXIT_FAILURE; } } printf("Elapsed time for %d index searches: %d seconds\n", N_RECORDS, (int)(time(NULL) - start)); rc = cli_drop_table(session, "foo"); if (rc != 0) { fprintf(stderr, "cli_drop_table failed with code %d\n", rc); return EXIT_FAILURE; } rc = cli_close(session); if (rc != cli_ok) { fprintf(stderr, "cli_close failed with code %d\n", rc); return EXIT_FAILURE; } printf("*** CLI alter test sucessfully passed!\n"); return EXIT_SUCCESS; }
bool torture_casetable(int dummy) { static struct cli_state *cli; char *fname; uint16_t fnum; int c, i; #define MAX_EQUIVALENCE 8 smb_ucs2_t equiv[0x10000][MAX_EQUIVALENCE]; printf("starting casetable\n"); if (!torture_open_connection(&cli, 0)) { return False; } memset(equiv, 0, sizeof(equiv)); cli_unlink(cli, "\\utable\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); cli_rmdir(cli, "\\utable"); if (!NT_STATUS_IS_OK(cli_mkdir(cli, "\\utable"))) { printf("Failed to create utable directory!\n"); return False; } for (c=1; c < 0x10000; c++) { SMB_OFF_T size; if (c == '.' || c == '\\') continue; printf("%04x (%c)\n", c, isprint(c)?c:'.'); fname = form_name(c); if (!NT_STATUS_IS_OK(cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_NONE, FILE_OPEN_IF, 0, 0, &fnum))) { printf("Failed to create file with char %04x\n", c); continue; } size = 0; if (!NT_STATUS_IS_OK(cli_qfileinfo_basic( cli, fnum, NULL, &size, NULL, NULL, NULL, NULL, NULL))) { continue; } if (size > 0) { /* found a character equivalence! */ int c2[MAX_EQUIVALENCE]; if (size/sizeof(int) >= MAX_EQUIVALENCE) { printf("too many chars match?? size=%ld c=0x%04x\n", (unsigned long)size, c); cli_close(cli, fnum); return False; } cli_read(cli, fnum, (char *)c2, 0, size); printf("%04x: ", c); equiv[c][0] = c; for (i=0; i<size/sizeof(int); i++) { printf("%04x ", c2[i]); equiv[c][i+1] = c2[i]; } printf("\n"); fflush(stdout); } cli_writeall(cli, fnum, 0, (uint8_t *)&c, size, sizeof(c), NULL); cli_close(cli, fnum); } cli_unlink(cli, "\\utable\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); cli_rmdir(cli, "\\utable"); return True; }
bool torture_utable(int dummy) { struct cli_state *cli; fstring fname, alt_name; uint16_t fnum; smb_ucs2_t c2; int c, len, fd; int chars_allowed=0, alt_allowed=0; uint8 valid[0x10000]; printf("starting utable\n"); if (!torture_open_connection(&cli, 0)) { return False; } memset(valid, 0, sizeof(valid)); cli_mkdir(cli, "\\utable"); cli_unlink(cli, "\\utable\\*", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); for (c=1; c < 0x10000; c++) { size_t size = 0; char *p; SSVAL(&c2, 0, c); fstrcpy(fname, "\\utable\\x"); p = fname+strlen(fname); if (!convert_string(CH_UTF16LE, CH_UNIX, &c2, 2, p, sizeof(fname)-strlen(fname),&size)) { d_printf("convert_string %s failed !\n", fname); continue; } len = size; p[len] = 0; fstrcat(fname,"_a_long_extension"); if (!NT_STATUS_IS_OK(cli_open(cli, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum))) { continue; } chars_allowed++; cli_qpathinfo_alt_name(cli, fname, alt_name); if (strncmp(alt_name, "X_A_L", 5) != 0) { alt_allowed++; valid[c] = 1; d_printf("fname=[%s] alt_name=[%s]\n", fname, alt_name); } cli_close(cli, fnum); cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); if (c % 100 == 0) { printf("%d (%d/%d)\r", c, chars_allowed, alt_allowed); } } printf("%d (%d/%d)\n", c, chars_allowed, alt_allowed); cli_rmdir(cli, "\\utable"); d_printf("%d chars allowed %d alt chars allowed\n", chars_allowed, alt_allowed); fd = open("valid.dat", O_WRONLY|O_CREAT|O_TRUNC, 0644); if (fd == -1) { d_printf("Failed to create valid.dat - %s", strerror(errno)); return False; } if (write(fd, valid, 0x10000) != 0x10000) { d_printf("Failed to create valid.dat - %s", strerror(errno)); close(fd); return false; } close(fd); d_printf("wrote valid.dat\n"); return True; }
static int /* O - 0 = success, non-0 = failure */ smb_print(struct cli_state * cli, /* I - SMB connection */ char *title, /* I - Title/job name */ FILE * fp) { /* I - File to print */ uint16_t fnum; /* File number */ int nbytes, /* Number of bytes read */ tbytes; /* Total bytes read */ char buffer[8192], /* Buffer for copy */ *ptr; /* Pointer into title */ NTSTATUS nt_status; /* * Sanitize the title... */ for (ptr = title; *ptr; ptr++) { if (!isalnum((int) *ptr) && !isspace((int) *ptr)) { *ptr = '_'; } } /* * Open the printer device... */ nt_status = cli_open(cli, title, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE, &fnum); if (!NT_STATUS_IS_OK(nt_status)) { fprintf(stderr, "ERROR: %s opening remote spool %s\n", nt_errstr(nt_status), title); return get_exit_code(cli, nt_status); } /* * Copy the file to the printer... */ if (fp != stdin) rewind(fp); tbytes = 0; while ((nbytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) { NTSTATUS status; status = cli_writeall(cli, fnum, 0, (uint8_t *)buffer, tbytes, nbytes, NULL); if (!NT_STATUS_IS_OK(status)) { int ret = get_exit_code(cli, status); fprintf(stderr, "ERROR: Error writing spool: %s\n", nt_errstr(status)); fprintf(stderr, "DEBUG: Returning status %d...\n", ret); cli_close(cli, fnum); return (ret); } tbytes += nbytes; } nt_status = cli_close(cli, fnum); if (!NT_STATUS_IS_OK(nt_status)) { fprintf(stderr, "ERROR: %s closing remote spool %s\n", nt_errstr(nt_status), title); return get_exit_code(cli, nt_status); } else { return (0); } }
static void do_atar(char *rname,char *lname,file_info *finfo1) { int fnum; SMB_BIG_UINT nread=0; char ftype; file_info2 finfo; BOOL close_done = False; BOOL shallitime=True; char data[65520]; int read_size = 65520; int datalen=0; struct timeval tp_start; GetTimeOfDay(&tp_start); ftype = '0'; /* An ordinary file ... */ if (finfo1) { finfo.size = finfo1 -> size; finfo.mode = finfo1 -> mode; finfo.uid = finfo1 -> uid; finfo.gid = finfo1 -> gid; finfo.mtime = finfo1 -> mtime; finfo.atime = finfo1 -> atime; finfo.ctime = finfo1 -> ctime; finfo.name = finfo1 -> name; } else { finfo.size = def_finfo.size; finfo.mode = def_finfo.mode; finfo.uid = def_finfo.uid; finfo.gid = def_finfo.gid; finfo.mtime = def_finfo.mtime; finfo.atime = def_finfo.atime; finfo.ctime = def_finfo.ctime; finfo.name = def_finfo.name; } if (dry_run) { DEBUG(3,("skipping file %s of size %12.0f bytes\n", finfo.name, (double)finfo.size)); shallitime=0; ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK); ntarf++; return; } fnum = cli_open(cli, rname, O_RDONLY, DENY_NONE); dos_clean_name(rname); if (fnum == -1) { DEBUG(0,("%s opening remote file %s (%s)\n", cli_errstr(cli),rname, cur_dir)); return; } finfo.name = string_create_s(strlen(rname)); if (finfo.name == NULL) { DEBUG(0, ("Unable to allocate space for finfo.name in do_atar\n")); return; } safe_strcpy(finfo.name,rname, strlen(rname)); if (!finfo1) { if (!cli_getattrE(cli, fnum, &finfo.mode, &finfo.size, NULL, &finfo.atime, &finfo.mtime)) { DEBUG(0, ("getattrE: %s\n", cli_errstr(cli))); return; } finfo.ctime = finfo.mtime; } DEBUG(3,("file %s attrib 0x%X\n",finfo.name,finfo.mode)); if (tar_inc && !(finfo.mode & aARCH)) { DEBUG(4, ("skipping %s - archive bit not set\n", finfo.name)); shallitime=0; } else if (!tar_system && (finfo.mode & aSYSTEM)) { DEBUG(4, ("skipping %s - system bit is set\n", finfo.name)); shallitime=0; } else if (!tar_hidden && (finfo.mode & aHIDDEN)) { DEBUG(4, ("skipping %s - hidden bit is set\n", finfo.name)); shallitime=0; } else { DEBUG(3,("getting file %s of size %.0f bytes as a tar file %s", finfo.name, (double)finfo.size, lname)); /* write a tar header, don't bother with mode - just set to 100644 */ writetarheader(tarhandle, rname, finfo.size, finfo.mtime, "100644 \0", ftype); while (nread < finfo.size && !close_done) { DEBUG(3,("nread=%.0f\n",(double)nread)); datalen = cli_read(cli, fnum, data, nread, read_size); if (datalen == -1) { DEBUG(0,("Error reading file %s : %s\n", rname, cli_errstr(cli))); break; } nread += datalen; /* if file size has increased since we made file size query, truncate read so tar header for this file will be correct. */ if (nread > finfo.size) { datalen -= nread - finfo.size; DEBUG(0,("File size change - truncating %s to %.0f bytes\n", finfo.name, (double)finfo.size)); } /* add received bits of file to buffer - dotarbuf will * write out in 512 byte intervals */ if (dotarbuf(tarhandle,data,datalen) != datalen) { DEBUG(0,("Error writing to tar file - %s\n", strerror(errno))); break; } if (datalen == 0) { DEBUG(0,("Error reading file %s. Got 0 bytes\n", rname)); break; } datalen=0; } /* pad tar file with zero's if we couldn't get entire file */ if (nread < finfo.size) { DEBUG(0, ("Didn't get entire file. size=%.0f, nread=%d\n", (double)finfo.size, (int)nread)); if (padit(data, sizeof(data), finfo.size - nread)) DEBUG(0,("Error writing tar file - %s\n", strerror(errno))); } /* round tar file to nearest block */ if (finfo.size % TBLOCK) dozerobuf(tarhandle, TBLOCK - (finfo.size % TBLOCK)); ttarf+=finfo.size + TBLOCK - (finfo.size % TBLOCK); ntarf++; } cli_close(cli, fnum); if (shallitime) { struct timeval tp_end; int this_time; /* if shallitime is true then we didn't skip */ if (tar_reset && !dry_run) (void) do_setrattr(finfo.name, aARCH, ATTRRESET); GetTimeOfDay(&tp_end); this_time = (tp_end.tv_sec - tp_start.tv_sec)*1000 + (tp_end.tv_usec - tp_start.tv_usec)/1000; get_total_time_ms += this_time; get_total_size += finfo.size; if (tar_noisy) { DEBUG(0, ("%12.0f (%7.1f kb/s) %s\n", (double)finfo.size, finfo.size / MAX(0.001, (1.024*this_time)), finfo.name)); } /* Thanks to Carel-Jan Engel ([email protected]) for this one */ DEBUG(3,("(%g kb/s) (average %g kb/s)\n", finfo.size / MAX(0.001, (1.024*this_time)), get_total_size / MAX(0.001, (1.024*get_total_time_ms)))); } }
BOOL cli_nt_session_open(struct cli_state *cli, const int pipe_idx) { int fnum; /* At the moment we can't have more than one pipe open over a cli connection. )-: */ SMB_ASSERT(cli->nt_pipe_fnum == 0); /* The pipe index must fall within our array */ SMB_ASSERT((pipe_idx >= 0) && (pipe_idx < PI_MAX_PIPES)); if (cli->capabilities & CAP_NT_SMBS) { if ((fnum = cli_nt_create(cli, &pipe_names[pipe_idx].client_pipe[5], DESIRED_ACCESS_PIPE)) == -1) { DEBUG(0,("cli_nt_session_open: cli_nt_create failed on pipe %s to machine %s. Error was %s\n", &pipe_names[pipe_idx].client_pipe[5], cli->desthost, cli_errstr(cli))); return False; } cli->nt_pipe_fnum = (uint16)fnum; } else { if ((fnum = cli_open(cli, pipe_names[pipe_idx].client_pipe, O_CREAT|O_RDWR, DENY_NONE)) == -1) { DEBUG(1,("cli_nt_session_open: cli_open failed on pipe %s to machine %s. Error was %s\n", pipe_names[pipe_idx].client_pipe, cli->desthost, cli_errstr(cli))); return False; } cli->nt_pipe_fnum = (uint16)fnum; /**************** Set Named Pipe State ***************/ if (!rpc_pipe_set_hnd_state(cli, pipe_names[pipe_idx].client_pipe, 0x4300)) { DEBUG(0,("cli_nt_session_open: pipe hnd state failed. Error was %s\n", cli_errstr(cli))); cli_close(cli, cli->nt_pipe_fnum); cli->nt_pipe_fnum = 0; return False; } } /******************* bind request on pipe *****************/ if (!rpc_pipe_bind(cli, pipe_idx, global_myname())) { DEBUG(2,("cli_nt_session_open: rpc bind to %s failed\n", get_pipe_name_from_index(pipe_idx))); cli_close(cli, cli->nt_pipe_fnum); cli->nt_pipe_fnum = 0; return False; } cli->pipe_idx = pipe_idx; /* * Setup the remote server name prefixed by \ and the machine account name. */ fstrcpy(cli->srv_name_slash, "\\\\"); fstrcat(cli->srv_name_slash, cli->desthost); strupper_m(cli->srv_name_slash); fstrcpy(cli->clnt_name_slash, "\\\\"); fstrcat(cli->clnt_name_slash, global_myname()); strupper_m(cli->clnt_name_slash); fstrcpy(cli->mach_acct, global_myname()); fstrcat(cli->mach_acct, "$"); strupper_m(cli->mach_acct); /* Remember which pipe we're talking to */ fstrcpy(cli->pipe_name, pipe_names[pipe_idx].client_pipe); return True; }
/* * Set file info on an SMB server. Use setpathinfo call first. If that * fails, use setattrE.. * * Access and modification time parameters are always used and must be * provided. Create time, if zero, will be determined from the actual create * time of the file. If non-zero, the create time will be set as well. * * "mode" (attributes) parameter may be set to -1 if it is not to be set. */ bool SMBC_setatr(SMBCCTX * context, SMBCSRV *srv, char *path, time_t create_time, time_t access_time, time_t write_time, time_t change_time, uint16_t mode) { uint16_t fd; int ret; TALLOC_CTX *frame = talloc_stackframe(); /* * First, try setpathinfo (if qpathinfo succeeded), for it is the * modern function for "new code" to be using, and it works given a * filename rather than requiring that the file be opened to have its * attributes manipulated. */ if (srv->no_pathinfo || !NT_STATUS_IS_OK(cli_setpathinfo_basic(srv->cli, path, create_time, access_time, write_time, change_time, mode))) { /* * setpathinfo is not supported; go to plan B. * * cli_setatr() does not work on win98, and it also doesn't * support setting the access time (only the modification * time), so in all cases, we open the specified file and use * cli_setattrE() which should work on all OS versions, and * supports both times. */ /* Don't try {q,set}pathinfo() again, with this server */ srv->no_pathinfo = True; /* Open the file */ if (!NT_STATUS_IS_OK(cli_open(srv->cli, path, O_RDWR, DENY_NONE, &fd))) { errno = SMBC_errno(context, srv->cli); TALLOC_FREE(frame); return -1; } /* Set the new attributes */ ret = NT_STATUS_IS_OK(cli_setattrE(srv->cli, fd, change_time, access_time, write_time)); /* Close the file */ cli_close(srv->cli, fd); /* * Unfortunately, setattrE() doesn't have a provision for * setting the access mode (attributes). We'll have to try * cli_setatr() for that, and with only this parameter, it * seems to work on win98. */ if (ret && mode != (uint16_t) -1) { ret = NT_STATUS_IS_OK(cli_setatr(srv->cli, path, mode, 0)); } if (! ret) { errno = SMBC_errno(context, srv->cli); TALLOC_FREE(frame); return False; } } TALLOC_FREE(frame); return True; }
int SMBC_close_ctx(SMBCCTX *context, SMBCFILE *file) { SMBCSRV *srv; char *server = NULL, *share = NULL, *user = NULL, *password = NULL; char *path = NULL; char *targetpath = NULL; struct cli_state *targetcli = NULL; TALLOC_CTX *frame = talloc_stackframe(); NTSTATUS status; if (!context || !context->internal->initialized) { errno = EINVAL; TALLOC_FREE(frame); return -1; } if (!file || !SMBC_dlist_contains(context->internal->files, file)) { errno = EBADF; TALLOC_FREE(frame); return -1; } /* IS a dir ... */ if (!file->file) { TALLOC_FREE(frame); return smbc_getFunctionClosedir(context)(context, file); } /*d_printf(">>>close: parsing %s\n", file->fname);*/ if (SMBC_parse_path(frame, context, file->fname, NULL, &server, &share, &path, &user, &password, NULL)) { errno = EINVAL; TALLOC_FREE(frame); return -1; } /*d_printf(">>>close: resolving %s\n", path);*/ status = cli_resolve_path(frame, "", context->internal->auth_info, file->srv->cli, path, &targetcli, &targetpath); if (!NT_STATUS_IS_OK(status)) { d_printf("Could not resolve %s\n", path); errno = ENOENT; TALLOC_FREE(frame); return -1; } /*d_printf(">>>close: resolved path as %s\n", targetpath);*/ if (!NT_STATUS_IS_OK(cli_close(targetcli, file->cli_fd))) { DEBUG(3, ("cli_close failed on %s. purging server.\n", file->fname)); /* Deallocate slot and remove the server * from the server cache if unused */ errno = SMBC_errno(context, targetcli); srv = file->srv; DLIST_REMOVE(context->internal->files, file); SAFE_FREE(file->fname); SAFE_FREE(file); smbc_getFunctionRemoveUnusedServer(context)(context, srv); TALLOC_FREE(frame); return -1; } DLIST_REMOVE(context->internal->files, file); SAFE_FREE(file->fname); SAFE_FREE(file); TALLOC_FREE(frame); return 0; }
static bool test_one(struct cli_state *cli, const char *name) { uint16_t fnum; fstring shortname; fstring name2; NTSTATUS status; TDB_DATA data; total++; status = cli_openx(cli, name, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum); if (!NT_STATUS_IS_OK(status)) { printf("open of %s failed (%s)\n", name, nt_errstr(status)); return False; } status = cli_close(cli, fnum); if (!NT_STATUS_IS_OK(status)) { printf("close of %s failed (%s)\n", name, nt_errstr(status)); return False; } /* get the short name */ status = cli_qpathinfo_alt_name(cli, name, shortname); if (!NT_STATUS_IS_OK(status)) { printf("query altname of %s failed (%s)\n", name, nt_errstr(status)); return False; } fstr_sprintf(name2, "\\mangle_test\\%s", shortname); status = cli_unlink(cli, name2, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); if (!NT_STATUS_IS_OK(status)) { printf("unlink of %s (%s) failed (%s)\n", name2, name, nt_errstr(status)); return False; } /* recreate by short name */ status = cli_openx(cli, name2, O_RDWR|O_CREAT|O_EXCL, DENY_NONE, &fnum); if (!NT_STATUS_IS_OK(status)) { printf("open2 of %s failed (%s)\n", name2, nt_errstr(status)); return False; } status = cli_close(cli, fnum); if (!NT_STATUS_IS_OK(status)) { printf("close of %s failed (%s)\n", name, nt_errstr(status)); return False; } /* and unlink by long name */ status = cli_unlink(cli, name, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); if (!NT_STATUS_IS_OK(status)) { printf("unlink2 of %s (%s) failed (%s)\n", name, name2, nt_errstr(status)); failures++; cli_unlink(cli, name2, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); return True; } /* see if the short name is already in the tdb */ data = tdb_fetch_bystring(tdb, shortname); if (data.dptr) { /* maybe its a duplicate long name? */ if (!strequal(name, (const char *)data.dptr)) { /* we have a collision */ collisions++; printf("Collision between %s and %s -> %s " " (coll/tot: %u/%u)\n", name, data.dptr, shortname, collisions, total); } free(data.dptr); } else { TDB_DATA namedata; /* store it for later */ namedata.dptr = discard_const_p(uint8_t, name); namedata.dsize = strlen(name)+1; tdb_store_bystring(tdb, shortname, namedata, TDB_REPLACE); } return True; }
NTSTATUS cli_nt_establish_netlogon(struct cli_state *cli, int sec_chan, const uchar trust_password[16]) { NTSTATUS result; uint32 neg_flags = NETLOGON_NEG_AUTH2_FLAGS; int fnum; cli_nt_netlogon_netsec_session_close(cli); if (lp_client_schannel() != False) neg_flags |= NETLOGON_NEG_SCHANNEL; result = cli_nt_setup_creds(cli, sec_chan, trust_password, &neg_flags, 2); if (!NT_STATUS_IS_OK(result)) { cli_nt_session_close(cli); return result; } if ((lp_client_schannel() == True) && ((neg_flags & NETLOGON_NEG_SCHANNEL) == 0)) { DEBUG(3, ("Server did not offer schannel\n")); cli_nt_session_close(cli); return NT_STATUS_UNSUCCESSFUL; } if ((lp_client_schannel() == False) || ((neg_flags & NETLOGON_NEG_SCHANNEL) == 0)) { return NT_STATUS_OK; /* keep the existing connection to NETLOGON open */ } /* Server offered schannel, so try it. */ memcpy(cli->auth_info.sess_key, cli->sess_key, sizeof(cli->auth_info.sess_key)); cli->saved_netlogon_pipe_fnum = cli->nt_pipe_fnum; cli->pipe_auth_flags = AUTH_PIPE_NETSEC; cli->pipe_auth_flags |= AUTH_PIPE_SIGN; cli->pipe_auth_flags |= AUTH_PIPE_SEAL; if (cli->capabilities & CAP_NT_SMBS) { /* The secure channel connection must be opened on the same session (TCP connection) as the one the challenge was requested from. */ if ((fnum = cli_nt_create(cli, PIPE_NETLOGON_PLAIN, DESIRED_ACCESS_PIPE)) == -1) { DEBUG(0,("cli_nt_create failed to %s machine %s. " "Error was %s\n", PIPE_NETLOGON, cli->desthost, cli_errstr(cli))); return NT_STATUS_UNSUCCESSFUL; } cli->nt_pipe_fnum = (uint16)fnum; } else { if ((fnum = cli_open(cli, PIPE_NETLOGON, O_CREAT|O_RDWR, DENY_NONE)) == -1) { DEBUG(0,("cli_open failed on pipe %s to machine %s. " "Error was %s\n", PIPE_NETLOGON, cli->desthost, cli_errstr(cli))); return NT_STATUS_UNSUCCESSFUL; } cli->nt_pipe_fnum = (uint16)fnum; /**************** Set Named Pipe State ***************/ if (!rpc_pipe_set_hnd_state(cli, PIPE_NETLOGON, 0x4300)) { DEBUG(0,("Pipe hnd state failed. Error was %s\n", cli_errstr(cli))); cli_close(cli, cli->nt_pipe_fnum); return NT_STATUS_UNSUCCESSFUL; } } if (!rpc_pipe_bind(cli, PI_NETLOGON, global_myname())) { DEBUG(2,("rpc bind to %s failed\n", PIPE_NETLOGON)); cli_close(cli, cli->nt_pipe_fnum); return NT_STATUS_UNSUCCESSFUL; } return NT_STATUS_OK; }
static int parse_quota_set(pstring set_str, pstring username_str, enum SMB_QUOTA_TYPE *qtype, int *cmd, SMB_NTQUOTA_STRUCT *pqt) { char *p = set_str,*p2; int todo; BOOL stop = False; BOOL enable = False; BOOL deny = False; if (strnequal(set_str,"UQLIM:",6)) { p += 6; *qtype = SMB_USER_QUOTA_TYPE; *cmd = QUOTA_SETLIM; todo = PARSE_LIM; if ((p2=strstr(p,":"))==NULL) { return -1; } *p2 = '\0'; p2++; fstrcpy(username_str,p); p = p2; } else if (strnequal(set_str,"FSQLIM:",7)) { p +=7; *qtype = SMB_USER_FS_QUOTA_TYPE; *cmd = QUOTA_SETLIM; todo = PARSE_LIM; } else if (strnequal(set_str,"FSQFLAGS:",9)) { p +=9; todo = PARSE_FLAGS; *qtype = SMB_USER_FS_QUOTA_TYPE; *cmd = QUOTA_SETFLAGS; } else { return -1; } switch (todo) { case PARSE_LIM: #if defined(HAVE_LONGLONG) if (sscanf(p,"%llu/%llu",&pqt->softlim,&pqt->hardlim)!=2) { #else if (sscanf(p,"%lu/%lu",&pqt->softlim,&pqt->hardlim)!=2) { #endif return -1; } break; case PARSE_FLAGS: while (!stop) { if ((p2=strstr(p,"/"))==NULL) { stop = True; } else { *p2 = '\0'; p2++; } if (strnequal(p,"QUOTA_ENABLED",13)) { enable = True; } else if (strnequal(p,"DENY_DISK",9)) { deny = True; } else if (strnequal(p,"LOG_SOFTLIMIT",13)) { pqt->qflags |= QUOTAS_LOG_THRESHOLD; } else if (strnequal(p,"LOG_HARDLIMIT",13)) { pqt->qflags |= QUOTAS_LOG_LIMIT; } else { return -1; } p=p2; } if (deny) { pqt->qflags |= QUOTAS_DENY_DISK; } else if (enable) { pqt->qflags |= QUOTAS_ENABLED; } break; } return 0; } static int do_quota(struct cli_state *cli, enum SMB_QUOTA_TYPE qtype, uint16 cmd, pstring username_str, SMB_NTQUOTA_STRUCT *pqt) { uint32 fs_attrs = 0; int quota_fnum = 0; SMB_NTQUOTA_LIST *qtl = NULL; SMB_NTQUOTA_STRUCT qt; ZERO_STRUCT(qt); if (!cli_get_fs_attr_info(cli, &fs_attrs)) { d_printf("Failed to get the filesystem attributes %s.\n", cli_errstr(cli)); return -1; } if (!(fs_attrs & FILE_VOLUME_QUOTAS)) { d_printf("Quotas are not supported by the server.\n"); return 0; } if (!cli_get_quota_handle(cli, "a_fnum)) { d_printf("Failed to open \\%s %s.\n", FAKE_FILE_NAME_QUOTA,cli_errstr(cli)); return -1; } switch(qtype) { case SMB_USER_QUOTA_TYPE: if (!StringToSid(&qt.sid, username_str)) { d_printf("StringToSid() failed for [%s]\n",username_str); return -1; } switch(cmd) { case QUOTA_GET: if (!cli_get_user_quota(cli, quota_fnum, &qt)) { d_printf("%s cli_get_user_quota %s\n", cli_errstr(cli),username_str); return -1; } dump_ntquota(&qt,verbose,numeric,SidToString); break; case QUOTA_SETLIM: pqt->sid = qt.sid; if (!cli_set_user_quota(cli, quota_fnum, pqt)) { d_printf("%s cli_set_user_quota %s\n", cli_errstr(cli),username_str); return -1; } if (!cli_get_user_quota(cli, quota_fnum, &qt)) { d_printf("%s cli_get_user_quota %s\n", cli_errstr(cli),username_str); return -1; } dump_ntquota(&qt,verbose,numeric,SidToString); break; case QUOTA_LIST: if (!cli_list_user_quota(cli, quota_fnum, &qtl)) { d_printf("%s cli_set_user_quota %s\n", cli_errstr(cli),username_str); return -1; } dump_ntquota_list(&qtl,verbose,numeric,SidToString); free_ntquota_list(&qtl); break; default: d_printf("Unknown Error\n"); return -1; } break; case SMB_USER_FS_QUOTA_TYPE: switch(cmd) { case QUOTA_GET: if (!cli_get_fs_quota_info(cli, quota_fnum, &qt)) { d_printf("%s cli_get_fs_quota_info\n", cli_errstr(cli)); return -1; } dump_ntquota(&qt,True,numeric,NULL); break; case QUOTA_SETLIM: if (!cli_get_fs_quota_info(cli, quota_fnum, &qt)) { d_printf("%s cli_get_fs_quota_info\n", cli_errstr(cli)); return -1; } qt.softlim = pqt->softlim; qt.hardlim = pqt->hardlim; if (!cli_set_fs_quota_info(cli, quota_fnum, &qt)) { d_printf("%s cli_set_fs_quota_info\n", cli_errstr(cli)); return -1; } if (!cli_get_fs_quota_info(cli, quota_fnum, &qt)) { d_printf("%s cli_get_fs_quota_info\n", cli_errstr(cli)); return -1; } dump_ntquota(&qt,True,numeric,NULL); break; case QUOTA_SETFLAGS: if (!cli_get_fs_quota_info(cli, quota_fnum, &qt)) { d_printf("%s cli_get_fs_quota_info\n", cli_errstr(cli)); return -1; } qt.qflags = pqt->qflags; if (!cli_set_fs_quota_info(cli, quota_fnum, &qt)) { d_printf("%s cli_set_fs_quota_info\n", cli_errstr(cli)); return -1; } if (!cli_get_fs_quota_info(cli, quota_fnum, &qt)) { d_printf("%s cli_get_fs_quota_info\n", cli_errstr(cli)); return -1; } dump_ntquota(&qt,True,numeric,NULL); break; default: d_printf("Unknown Error\n"); return -1; } break; default: d_printf("Unknown Error\n"); return -1; } cli_close(cli, quota_fnum); return 0; }
static void ofs_destroy(void *UNUSED(private_data)) { fprintf(stderr, "terminating...\n"); cli_close(); return; }
/***************************************************** a wrapper for open() *******************************************************/ int smbw_open(const char *fname, int flags, mode_t mode) { fstring server, share; pstring path; struct smbw_server *srv=NULL; int eno=0, fd = -1; struct smbw_file *file=NULL; smbw_init(); if (!fname) { errno = EINVAL; return -1; } smbw_busy++; /* work out what server they are after */ smbw_parse_path(fname, server, share, path); /* get a connection to the server */ srv = smbw_server(server, share); if (!srv) { /* smbw_server sets errno */ goto failed; } if (path[strlen(path)-1] == '\\') { fd = -1; } else { fd = cli_open(&srv->cli, path, flags, DENY_NONE); } if (fd == -1) { /* it might be a directory. Maybe we should use chkpath? */ eno = smbw_errno(&srv->cli); fd = smbw_dir_open(fname); if (fd == -1) errno = eno; smbw_busy--; return fd; } file = (struct smbw_file *)malloc(sizeof(*file)); if (!file) { errno = ENOMEM; goto failed; } ZERO_STRUCTP(file); file->f = (struct smbw_filedes *)malloc(sizeof(*(file->f))); if (!file->f) { errno = ENOMEM; goto failed; } ZERO_STRUCTP(file->f); file->f->cli_fd = fd; file->f->fname = strdup(path); if (!file->f->fname) { errno = ENOMEM; goto failed; } file->srv = srv; file->fd = open(SMBW_DUMMY, O_WRONLY); if (file->fd == -1) { errno = EMFILE; goto failed; } if (bitmap_query(smbw_file_bmap, file->fd)) { DEBUG(0,("ERROR: fd used in smbw_open\n")); errno = EIO; goto failed; } file->f->ref_count=1; bitmap_set(smbw_file_bmap, file->fd); DLIST_ADD(smbw_files, file); DEBUG(4,("opened %s\n", fname)); smbw_busy--; return file->fd; failed: if (fd != -1) { cli_close(&srv->cli, fd); } if (file) { if (file->f) { SAFE_FREE(file->f->fname); SAFE_FREE(file->f); } SAFE_FREE(file); } smbw_busy--; return -1; }
int main(int argc, char *argv[]) { int res; while (1) { int option_index = 0; int c; static struct option long_options[] = { {"irda", no_argument, NULL, 'i'}, {"bluetooth", required_argument, NULL, 'b'}, {"channel", required_argument, NULL, 'B'}, {"hci", required_argument, NULL, 'd'}, {"usb", required_argument, NULL, 'u'}, {"tty", required_argument, NULL, 't'}, {"network", required_argument, NULL, 'n'}, {"nonblock", no_argument, NULL, 'N'}, {"help", no_argument, NULL, 'h'}, {"usage", no_argument, NULL, 'h'}, {0, 0, 0, 0} }; c = getopt_long (argc, argv, "+ib:B:d:u:t:n:Nh", long_options, &option_index); if (c == -1) break; switch (c) { case 'i': transport = OBEX_TRANS_IRDA; device = NULL; channel = 0; break; case 'b': transport = OBEX_TRANS_BLUETOOTH; device = optarg; channel = -1; break; case 'B': channel = atoi(optarg); break; case 'd': source = optarg; break; case 'u': if (geteuid() != 0) fprintf(stderr, "If USB doesn't work setup permissions in udev or run as superuser.\n"); transport = OBEX_TRANS_USB; device = NULL; channel = atoi(optarg); break; case 't': transport = OBEX_TRANS_CUSTOM; device = optarg; channel = 0; break; case 'n': transport = OBEX_TRANS_INET; device = optarg; channel = 650; { int n; if (sscanf(optarg, "%d.%d.%d.%d", &n, &n, &n, &n) != 4) fprintf(stderr, "Please use dotted quad notation.\n"); } break; case 'N': nonblock = 1; break; case 'h': /* printf("ObexFS %s\n", VERSION); */ printf("Usage: %s [-i | -b <dev> [-B <chan>] [-d <hci>] | -u <dev> | -t <dev> | -n <dev>] [-- <fuse options>]\n" "Transfer files from/to Mobile Equipment.\n" "Copyright (c) 2002-2005 Christian W. Zuckschwerdt\n" "\n" " -i, --irda connect using IrDA transport\n" " -b, --bluetooth <device> connect to this bluetooth device\n" " -B, --channel <number> use this bluetooth channel when connecting\n" " -d, --hci <no/address> use source device with this address or number\n" " -u, --usb <interface> connect to this usb interface number\n" " -t, --tty <device> connect to this tty using a custom transport\n" " -n, --network <device> connect to this network host\n\n" " -N, --nonblock nonblocking mode\n\n" " -h, --help, --usage this help text\n\n" "Options to fusermount need to be preceeded by two dashes (--).\n" "\n", argv[0]); exit(0); break; default: printf("Try `%s --help' for more information.\n", argv[0]); exit(0); } } if (transport == 0) { fprintf(stderr, "No device selected. Use --help for help.\n"); exit(0); } argv[optind-1] = argv[0]; /* Open connection */ res = cli_open(); if(res < 0) return res; /* errno */ /* loop */ fuse_main(argc-optind+1, &argv[optind-1], &ofs_oper); /* Close connection */ cli_close(); return 0; }