static int open_f (stream_t *stream, int mode, void *opts, int* file_format) { struct stream_priv_s *p = (struct stream_priv_s*)opts; char *filename; mode_t m = 0; off_t len; int fd, err; filename = stream->url; if(mode == STREAM_READ) m = O_RDONLY; else if (mode == STREAM_WRITE) //who's gonna do that ? m = O_RDWR|O_CREAT|O_TRUNC; else { mp_msg(MSGT_OPEN, MSGL_ERR, "[smb] Unknown open mode %d\n", mode); m_struct_free (&stream_opts, opts); return STREAM_UNSUPPORTED; } if(!filename) { mp_msg(MSGT_OPEN,MSGL_ERR, "[smb] Bad url\n"); m_struct_free(&stream_opts, opts); return STREAM_ERROR; } err = smbc_init(smb_auth_fn, 1); if (err < 0) { mp_msg(MSGT_OPEN,MSGL_ERR,MSGTR_SMBInitError,err); m_struct_free(&stream_opts, opts); return STREAM_ERROR; } fd = smbc_open(filename, m,0644); if (fd < 0) { mp_msg(MSGT_OPEN,MSGL_ERR,MSGTR_SMBFileNotFound, filename); m_struct_free(&stream_opts, opts); return STREAM_ERROR; } stream->flags = mode; len = 0; if(mode == STREAM_READ) { len = smbc_lseek(fd,0,SEEK_END); smbc_lseek (fd, 0, SEEK_SET); } if(len > 0 || mode == STREAM_WRITE) { stream->flags |= MP_STREAM_SEEK; stream->seek = seek; if(mode == STREAM_READ) stream->end_pos = len; } stream->type = STREAMTYPE_SMB; stream->fd = fd; stream->fill_buffer = fill_buffer; stream->write_buffer = write_buffer; stream->close = close_f; stream->control = control; m_struct_free(&stream_opts, opts); return STREAM_OK; }
int main(int argc, char** argv) { int err = -1; int fd = 0; char url[MAX_BUFF_SIZE]; struct stat st; memset(g_workgroup, '\0', MAX_BUFF_SIZE); memset(url, '\0', MAX_BUFF_SIZE); if ( argc == 5 ) { strncpy(g_workgroup,argv[1],strlen(argv[1])); strncpy(g_username,argv[2],strlen(argv[2])); strncpy(g_password,argv[3],strlen(argv[3])); strncpy(url,argv[4],strlen(argv[4])); smbc_init(auth_fn, 0); fd = smbc_open(url,O_RDWR | O_CREAT, 0666); smbc_close(fd); smbc_stat(url, &st); err = errno; } return err; }
int get_smb_server_fd(struct SMB_DS *ds, char* filename) { int ret, fd, i; char buf[256+1]; ret = smbc_init(smb_auth_fn, 0);NE_ERR(ret, 0); for(i=0;i<strlen(ds->path);i++) { if(ds->path[i]=='\\') ds->path[i] = '/'; } sprintf(buf, "smb://%s/%s/%s", ds->server, ds->path, filename); buf[256]='\0'; //fprintf(stderr, "%s\n", buf); if(ds->user[0]!='\0') strcpy(smb_username, ds->user); else strcpy(smb_username, "dummy"); strcpy(smb_password, ds->passwd); //fprintf(stderr, "%s %s\n", smb_username, smb_password); fd = smbc_open(buf, O_RDWR | O_CREAT | O_TRUNC, 0666);EQ_ERR(fd, -1); return fd; errout: if(fd != -1) smbc_close(fd); return -1; }
int main(int argc, char** argv) { int err = -1; char url[MAX_BUFF_SIZE]; bzero(g_workgroup,MAX_BUFF_SIZE); bzero(url,MAX_BUFF_SIZE); if ( argc == 5 ) { strncpy( g_workgroup, argv[1], strlen(argv[1]) ); strncpy( g_username, argv[2], strlen(argv[2]) ); strncpy( g_password, argv[3], strlen(argv[3]) ); strncpy( url, argv[4], strlen(argv[4]) ); smbc_init( auth_fn, 0 ); smbc_rmdir( url ); smbc_mkdir( url, 0666 ); smbc_mkdir( url, 0666 ); err = errno; } return err; }
int main(int argc, char** argv) { int err = -1; int fd = 0; char url[MAX_BUFF_SIZE]; bzero(g_workgroup,MAX_BUFF_SIZE); bzero(url,MAX_BUFF_SIZE); if ( argc == 5 ) { strncpy(g_workgroup,argv[1],strlen(argv[1])); strncpy(g_username,argv[2],strlen(argv[2])); strncpy(g_password,argv[3],strlen(argv[3])); strncpy(url,argv[4],strlen(argv[4])); smbc_init(auth_fn, 0); smbc_unlink(url); fd = smbc_open(url,O_RDWR|O_CREAT,0666); smbc_close(fd); smbc_opendir(url); err = errno; } return err; }
int main(int argc, char* argv[]) { int fd; struct stat st1; struct stat st2; char * pUrl = argv[1]; if(argc != 2) { printf("usage: %s <file_url>\n", argv[0]); return 1; } smbc_init(get_auth_data_fn, 0); if (smbc_stat(pUrl, &st1) < 0) { perror("smbc_stat"); return 1; } if ((fd = smbc_open(pUrl, O_RDONLY, 0)) < 0) { perror("smbc_open"); return 1; } if (smbc_fstat(fd, &st2) < 0) { perror("smbc_fstat"); return 1; } smbc_close(fd); #define COMPARE(name, field) \ if (st1.field != st2.field) \ { \ printf("Field " name " MISMATCH: st1=%lu, st2=%lu\n", \ (unsigned long) st1.field, \ (unsigned long) st2.field); \ } COMPARE("st_dev", st_dev); COMPARE("st_ino", st_ino); COMPARE("st_mode", st_mode); COMPARE("st_nlink", st_nlink); COMPARE("st_uid", st_uid); COMPARE("st_gid", st_gid); COMPARE("st_rdev", st_rdev); COMPARE("st_size", st_size); COMPARE("st_blksize", st_blksize); COMPARE("st_blocks", st_blocks); COMPARE("st_atime", st_atime); COMPARE("st_mtime", st_mtime); COMPARE("st_ctime", st_ctime); return 0; }
int main(int argc, char** argv) { int err = -1; char url[MAX_BUFF_SIZE]; memset(g_workgroup, '\0', MAX_BUFF_SIZE); memset(url, '\0', MAX_BUFF_SIZE); if ( argc == 5 ) { strncpy(g_workgroup,argv[1],strlen(argv[1])); strncpy(g_username,argv[2],strlen(argv[2])); strncpy(g_password,argv[3],strlen(argv[3])); strncpy(url,argv[4],strlen(argv[4])); smbc_init(auth_fn, 0); err = smbc_unlink(url); if ( err < 0 ) err = 1; } return 1; }
int main(int argc, char** argv) { int err = -1; char url[MAX_BUFF_SIZE]; memset(g_workgroup, '\0', MAX_BUFF_SIZE); memset(url, '\0', MAX_BUFF_SIZE); if ( argc == 6 ) { strncpy(g_workgroup,argv[1],strlen(argv[1])); strncpy(g_username,argv[2],strlen(argv[2])); strncpy(g_password,argv[3],strlen(argv[3])); strncpy(url,argv[4],strlen(argv[4])); smbc_init(auth_fn, 0); smbc_rename( url, argv[5] ); err = errno; } return err; }
int main(int argc, char** argv) { int err = -1; int fd = 0; char* message = "Testing"; memset(g_workgroup, '\0', MAX_BUFF_SIZE); if ( argc == 4 ) { strncpy(g_workgroup,argv[1],strlen(argv[1])); strncpy(g_username,argv[2],strlen(argv[2])); strncpy(g_password,argv[3],strlen(argv[3])); fd = 10345; /* Random value for File Descriptor */ smbc_init(auth_fn, 0); err = smbc_read(fd, message, sizeof(message)); if ( err < 0 ) err = 1; else err = 0; } return err; }
int main(int argc, char** argv) { int err = -1; int fd1 = 0; char url[MAX_BUFF_SIZE]; memset(g_workgroup, '\0', MAX_BUFF_SIZE); memset(url, '\0', MAX_BUFF_SIZE); if ( argc == 5 ) { strncpy( g_workgroup, argv[1], strlen(argv[1]) ); strncpy( g_username, argv[2], strlen(argv[2]) ); strncpy( g_password, argv[3], strlen(argv[3]) ); strncpy( url, argv[4], strlen(argv[4]) ); smbc_init( auth_fn, 0 ); fd1 = smbc_open( url, O_RDWR | O_CREAT, 0666 ); smbc_close( fd1 ); err = smbc_rmdir( url ); if ( err < 0 ) err = 1; else err = 0; } return err; }
int main(int argc, char** argv) { int err = -1; int fd = 0; bzero(g_workgroup,MAX_BUFF_SIZE); if ( argc == 4 ) { strncpy(g_workgroup,argv[1],strlen(argv[1])); strncpy(g_username,argv[2],strlen(argv[2])); strncpy(g_password,argv[3],strlen(argv[3])); smbc_init(auth_fn, 0); fd = -1; err = smbc_lseek(fd, 0, SEEK_SET); if ( err < 0 ) err = 1; else err = 0; } return err; }
int main(int argc, char** argv) { int err = -1; int fd = 0; memset(g_workgroup, '\0', MAX_BUFF_SIZE); if ( argc == 4 ) { strncpy(g_workgroup,argv[1],strlen(argv[1])); strncpy(g_username,argv[2],strlen(argv[2])); strncpy(g_password,argv[3],strlen(argv[3])); smbc_init(auth_fn, 0); fd = -1; smbc_lseek(fd, 0, SEEK_SET); err = errno; } return err; }
int main(int argc, char** argv) { int err = -1; int dh = 0; char url[MAX_BUFF_SIZE]; bzero(g_workgroup,MAX_BUFF_SIZE); bzero(url,MAX_BUFF_SIZE); if ( argc == 5 ) { strncpy(g_workgroup,argv[1],strlen(argv[1])); strncpy(g_username,argv[2],strlen(argv[2])); strncpy(g_password,argv[3],strlen(argv[3])); strncpy(url,argv[4],strlen(argv[4])); smbc_init(auth_fn, 0); dh = smbc_opendir(url); /* printf("directory handle: %i\n",dh); */ smbc_closedir(dh); err = errno; } return err; }
int main(int argc, char** argv) { int err = -1; int fd = 0; char url[MAX_BUFF_SIZE]; memset(g_workgroup, '\0', MAX_BUFF_SIZE); memset(url, '\0', MAX_BUFF_SIZE); if ( argc == 5 ) { strncpy(g_workgroup,argv[1],strlen(argv[1])); strncpy(g_username,argv[2],strlen(argv[2])); strncpy(g_password,argv[3],strlen(argv[3])); strncpy(url,argv[4],strlen(argv[4])); fd = smbc_init(auth_fn, 0); if ( fd < 0 ) err = 1; else err = 0; } return err; }
int main(int argc, char** argv) { int err = -1; char url[MAX_BUFF_SIZE]; bzero(g_workgroup,MAX_BUFF_SIZE); bzero(url,MAX_BUFF_SIZE); if ( argc == 6 ) { strncpy(g_workgroup,argv[1],strlen(argv[1])); strncpy(g_username,argv[2],strlen(argv[2])); strncpy(g_password,argv[3],strlen(argv[3])); strncpy(url,argv[4],strlen(argv[4])); smbc_init(auth_fn, 0); err = smbc_print_file(url,argv[6]); if ( err < 0 ) err = 1; else err = 0; } return err; }
static gboolean xmms_samba_plugin_setup (xmms_xform_plugin_t *xform_plugin) { xmms_xform_methods_t methods; gint err; XMMS_XFORM_METHODS_INIT (methods); methods.init = xmms_samba_init; methods.destroy = xmms_samba_destroy; methods.read = xmms_samba_read; methods.seek = xmms_samba_seek; methods.browse = xmms_samba_browse; xmms_xform_plugin_methods_set (xform_plugin, &methods); xmms_xform_plugin_indata_add (xform_plugin, XMMS_STREAM_TYPE_MIMETYPE, "application/x-url", XMMS_STREAM_TYPE_URL, "smb://*", XMMS_STREAM_TYPE_END); g_static_mutex_lock (&mutex); err = smbc_init (xmms_samba_auth_fn, 0); g_static_mutex_unlock (&mutex); if (err < 0) { xmms_log_error ("%s", strerror (errno)); return FALSE; } return TRUE; }
int main(int argc, char** argv) { int err = -1; char url[MAX_BUFF_SIZE]; bzero(g_workgroup,MAX_BUFF_SIZE); bzero(url,MAX_BUFF_SIZE); if ( argc == 6 ) { strncpy(g_workgroup,argv[1],strlen(argv[1])); strncpy(g_username,argv[2],strlen(argv[2])); strncpy(g_password,argv[3],strlen(argv[3])); strncpy(url,argv[4],strlen(argv[4])); smbc_init(auth_fn, 0); smbc_open(url,O_RDWR | O_CREAT,0666); err = smbc_rename( url, argv[5] ); if ( err < 0 ) err = 1; } return err; }
int SMB_init(int index) { strcpy(g_workgroup, smb_config.multrule[index]->workgroup); strcpy(g_username, smb_config.multrule[index]->acount); strcpy(g_password, smb_config.multrule[index]->password); smbc_init(auth_fn, 0); return 0; }
/* * FUNCTION : static BOOL access_dir(char* name, char* user, char *passwd) * DESCRIPTION : check user can access directory or not * INPUT : char* name - server name * char* user - username * char *passwd - password * int id - * OUTPUT : N/A * RETURN : TRUE - can access * FALSE - can't access */ void *access_dir(void *value) { int err, dh1; char url[MAX_NAME_LEN] = {0}; struct smbserverinfo_t *psmbserverinfo = NULL; if(value == NULL) return NULL; psmbserverinfo = (struct smbserverinfo_t *)value; printf("%s[%d], name = [%s], ip = [%s], user = [%s], passwd = [%s], cmd_id = [%d]\n", __FILE__, __LINE__, psmbserverinfo->name, psmbserverinfo->ip, psmbserverinfo->user, psmbserverinfo->passwd, psmbserverinfo->cmd_id); memset(smb_username, 0, sizeof(smb_username)); memset(smb_passwd, 0, sizeof(smb_passwd)); if(psmbserverinfo->user != NULL) { strncpy(smb_username, psmbserverinfo->user, strlen(psmbserverinfo->user)); smb_username[strlen(psmbserverinfo->user)] = '\0'; } if(psmbserverinfo->passwd != NULL) { strncpy(smb_passwd, psmbserverinfo->passwd, strlen(psmbserverinfo->passwd)); smb_passwd[strlen(psmbserverinfo->passwd)] = '\0'; } printf("%s[%d], smb_username = [%s], smb_passwd = [%s]\n", __FILE__, __LINE__, smb_username, smb_passwd); snprintf(url, sizeof(url), "smb://%s:%s@%s", smb_username, smb_passwd, psmbserverinfo->name); err = smbc_init(get_static_auth_data_fn, 0); /* Initialize things */ if (err < 0) { printf("%s[%d], Initializing the smbclient library ...: %s\n", __FILE__, __LINE__, strerror(errno)); if(errno == EACCES) { printf("\033[1;33;41m%s[%d], errno = EACCES (%s)\033[0m\n", __FILE__, __LINE__, strerror(errno)); SMBTREE_send_event_to_OSD(SMB_CMD_ACCESS_RESPONSE, SMB_ACCESS_LOGIN_FAILED, psmbserverinfo->cmd_id, NULL); } else { printf("\033[1;33;41m%s[%d], SMB_ACCESS_FAILED\033[0m\n", __FILE__, __LINE__); SMBTREE_send_event_to_OSD(SMB_CMD_ACCESS_RESPONSE, SMB_ACCESS_FAILED, psmbserverinfo->cmd_id, NULL); } SMBTREE_free_smbserverinfo(psmbserverinfo); return NULL; } if ((dh1 = smbc_opendir(url))<1) { printf("%s[%d], Could not open directory: %s: %s\n", __FILE__, __LINE__, url, strerror(errno)); if(errno == EACCES) { printf("\033[1;33;41m%s[%d], errno = EACCES (%s)\033[0m\n", __FILE__, __LINE__, strerror(errno)); SMBTREE_send_event_to_OSD(SMB_CMD_ACCESS_RESPONSE, SMB_ACCESS_LOGIN_FAILED, psmbserverinfo->cmd_id, NULL); } else { printf("\033[1;33;41m%s[%d], SMB_ACCESS_FAILED\033[0m\n", __FILE__, __LINE__); SMBTREE_send_event_to_OSD(SMB_CMD_ACCESS_RESPONSE, SMB_ACCESS_FAILED, psmbserverinfo->cmd_id, NULL); } SMBTREE_free_smbserverinfo(psmbserverinfo); return NULL; } smbc_closedir(dh1); SMBTREE_send_event_to_OSD(SMB_CMD_ACCESS_RESPONSE, SMB_ACCESS_OK, psmbserverinfo->cmd_id, NULL); SMBTREE_free_smbserverinfo(psmbserverinfo); return NULL; }
static int open_f (stream_t *stream, int mode) { char *filename; mode_t m = 0; int64_t len; int fd, err; struct priv *priv = talloc_zero(stream, struct priv); stream->priv = priv; filename = stream->url; if(mode == STREAM_READ) m = O_RDONLY; else if (mode == STREAM_WRITE) //who's gonna do that ? m = O_RDWR|O_CREAT|O_TRUNC; else { MP_ERR(stream, "[smb] Unknown open mode %d\n", mode); return STREAM_UNSUPPORTED; } if(!filename) { MP_ERR(stream, "[smb] Bad url\n"); return STREAM_ERROR; } err = smbc_init(smb_auth_fn, 1); if (err < 0) { MP_ERR(stream, "Cannot init the libsmbclient library: %d\n",err); return STREAM_ERROR; } fd = smbc_open(filename, m,0644); if (fd < 0) { MP_ERR(stream, "Could not open from LAN: '%s'\n", filename); return STREAM_ERROR; } stream->flags = mode; len = 0; if(mode == STREAM_READ) { len = smbc_lseek(fd,0,SEEK_END); smbc_lseek (fd, 0, SEEK_SET); } if(len > 0 || mode == STREAM_WRITE) { stream->flags |= MP_STREAM_SEEK; stream->seek = seek; if(mode == STREAM_READ) stream->end_pos = len; } priv->fd = fd; stream->fill_buffer = fill_buffer; stream->write_buffer = write_buffer; stream->close = close_f; stream->control = control; return STREAM_OK; }
int main(int argc, char** argv) { int err = -1; int fd = 0; int msg_len = 0; char url[MAX_BUFF_SIZE]; char* message; bzero(g_workgroup,MAX_BUFF_SIZE); bzero(url,MAX_BUFF_SIZE); bzero(g_print_user,MAX_BUFF_SIZE); bzero(g_print_name,MAX_BUFF_SIZE); g_print_id = 0; g_print_priority = 0; g_print_size = 0; if ( argc == 7 ) { strncpy(g_workgroup,argv[1],strlen(argv[1])); strncpy(g_username,argv[2],strlen(argv[2])); strncpy(g_password,argv[3],strlen(argv[3])); strncpy(url,argv[4],strlen(argv[4])); msg_len = strlen(argv[5])+1; message = malloc(msg_len); message[msg_len - 1] = 0; strncpy(message,argv[5],msg_len); /* printf("Message: %s\n",message); */ /* printf("Message len: %i\n",msg_len); */ smbc_init(auth_fn, 0); smbc_unlink(url); fd = smbc_open(url,O_RDWR | O_CREAT, 0666); smbc_write(fd, message, msg_len); smbc_close(fd); free(message); smbc_print_file(url,argv[6]); smbc_list_print_jobs(argv[6],print_list_fn); g_print_id = -1; err = smbc_unlink_print_job(argv[6],g_print_id); if ( err < 0 ) err = 1; else err = 0; } return err; }
int main(int argc, char** argv) { int err = -1; int fd = 0; int msg_len = 0; char url[MAX_BUFF_SIZE]; char* message; char* response; memset(g_workgroup, '\0', MAX_BUFF_SIZE); memset(url, '\0', MAX_BUFF_SIZE); if ( argc == 6 ) { strncpy(g_workgroup,argv[1],strlen(argv[1])); strncpy(g_username,argv[2],strlen(argv[2])); strncpy(g_password,argv[3],strlen(argv[3])); strncpy(url,argv[4],strlen(argv[4])); msg_len = strlen(argv[5])+1; message = malloc(msg_len); response = malloc(msg_len); message[msg_len - 1] = 0; strncpy(message,argv[5],msg_len); smbc_init(auth_fn, 0); smbc_unlink(url); fd = smbc_open(url,O_RDWR | O_CREAT, 0666); smbc_close(fd); strncpy(g_username,"xxxxxxxx",8); strncpy(g_password,"xxxxxxxx",8); fd = smbc_open(url, O_RDWR, 0666); if (fd < 0) err = errno; else { smbc_write(fd, message, msg_len); err = errno; smbc_close(fd); } free(message); free(response); } return err; }
int main(int argc, char * argv[]) { int ret; int debug = 0; int mode = 0666; char buffer[16384]; char * pSmbPath = NULL; struct stat st; if (argc == 1) { pSmbPath = "smb://RANDOM/Public/small"; } else if (argc == 2) { pSmbPath = argv[1]; } else if (argc == 3) { pSmbPath = argv[1]; mode = (int) strtol(argv[2], NULL, 8); } else { printf("usage: " "%s [ smb://path/to/file [ octal_mode ] ]\n", argv[0]); return 1; } smbc_init(get_auth_data_fn, debug); if (smbc_stat(pSmbPath, &st) < 0) { perror("smbc_stat"); return 1; } printf("\nBefore chmod: mode = %04o\n", st.st_mode); if (smbc_chmod(pSmbPath, mode) < 0) { perror("smbc_chmod"); return 1; } if (smbc_stat(pSmbPath, &st) < 0) { perror("smbc_stat"); return 1; } printf("After chmod: mode = %04o\n", st.st_mode); return 0; }
int main(int argc, char **argv) { if (argc <= 1) { usage(); } smbc_init(samba_auth_data_fn, 0); if (argc==3 && argv[1][0]=='-' && argv[1][1]=='r') { struct in_addr ip; if (samba_resolve_name(argv[2], &ip, 0x20)) { puts(START_OUTPUT); puts(inet_ntoa(ip)); return 0; } else return E_NAMENOTFOUND; } int i; for (i = 1; i <= argc; i++) { if (argv[i][0]=='-' && argv[i][1]=='u') { i++; g_user = argv[i]; } else if (argv[i][0]=='-' && argv[i][1]=='p') { i++; g_pass = argv[i]; } else { g_path = argv[i]; break; } } int dh = smbc_opendir(g_path); if (dh < 0) return errno == EACCES ? E_ACCESS : E_OPENDIRFAILED; puts(START_OUTPUT); struct smbc_dirent *pdirent; while ((pdirent = smbc_readdir(dh)) != NULL) { if (pdirent->name[strlen(pdirent->name)-1] != '$') puts(pdirent->name); } smbc_closedir(dh); return 0; }
int main(int argc, char * argv[]) { int fd; int ret; int debug = 0; int savedErrno; char buffer[2048]; char path[2048]; char * p; smbc_init(get_auth_data_fn, debug); printf("CAUTION: This program will overwrite a file. " "Press ENTER to continue."); fgets(buffer, sizeof(buffer), stdin); for (;;) { fprintf(stdout, "\nPath: "); *path = '\0'; fgets(path, sizeof(path) - 1, stdin); if (strlen(path) == 0) { return 0; } p = path + strlen(path) - 1; if (*p == '\n') { *p = '\0'; } if ((fd = smbc_open(path, O_WRONLY | O_CREAT | O_TRUNC, 0)) < 0) { perror("smbc_open"); continue; } snprintf(buffer, sizeof(buffer), "%s", "Hello world\n"); ret = smbc_write(fd, buffer, strlen(buffer)); savedErrno = errno; smbc_close(fd); if (ret < 0) { errno = savedErrno; perror("write"); } } return 0; }
int main(int argc, char** argv) { int err = -1; int fd = 0; int msg_len = 0; char url[MAX_BUFF_SIZE]; char* message; char* response; bzero(g_workgroup,MAX_BUFF_SIZE); bzero(url,MAX_BUFF_SIZE); if ( argc == 6 ) { strncpy(g_workgroup,argv[1],strlen(argv[1])); strncpy(g_username,argv[2],strlen(argv[2])); strncpy(g_password,argv[3],strlen(argv[3])); strncpy(url,argv[4],strlen(argv[4])); msg_len = strlen(argv[5])+1; message = malloc(msg_len); response = malloc(msg_len); message[msg_len - 1] = 0; strncpy(message,argv[5],msg_len); smbc_init(auth_fn, 0); smbc_unlink(url); fd = smbc_open(url,O_RDWR | O_CREAT, 0666); smbc_write(fd, message, msg_len); smbc_close(fd); fd = smbc_open(url,O_WRONLY, 0666); err = smbc_read(fd,response,msg_len); free(message); free(response); if ( err < 0 ) err = 1; else if ( err != msg_len ) err = 1; else err = 0; } return err; }
static gboolean xmms_samba_plugin_setup (xmms_xform_plugin_t *xform_plugin) { xmms_xform_methods_t methods; gint err; XMMS_XFORM_METHODS_INIT (methods); methods.init = xmms_samba_init; methods.destroy = xmms_samba_destroy; methods.read = xmms_samba_read; methods.seek = xmms_samba_seek; methods.browse = xmms_samba_browse; xmms_xform_plugin_methods_set (xform_plugin, &methods); xmms_xform_plugin_indata_add (xform_plugin, XMMS_STREAM_TYPE_MIMETYPE, "application/x-url", XMMS_STREAM_TYPE_URL, "smb://*", XMMS_STREAM_TYPE_END); G_LOCK (mutex); if (smbc_set_context (NULL) == NULL) { /* This should really be cleaned up when the program closes. * However, given that we have no means of doing so, we're * just going to forget that we ever created it and let the OS * clean up after us. */ SMBCCTX *ctx = smbc_new_context (); if (ctx == NULL) { xmms_log_error ("Failed to create SMBCCTX.", NULL); return FALSE; } if (smbc_init_context (ctx) == NULL) { xmms_log_error ("Failed to init SMBCCTX.", NULL); smbc_free_context (ctx, 1); return FALSE; } smbc_setOptionUseKerberos (ctx, TRUE); smbc_setOptionFallbackAfterKerberos (ctx, TRUE); smbc_set_context (ctx); } err = smbc_init (xmms_samba_auth_fn, 0); G_UNLOCK (mutex); if (err < 0) { xmms_log_error ("%s", strerror (errno)); return FALSE; } return TRUE; }
int main(int argc, char** argv) { int err = -1; char url[MAX_BUFF_SIZE]; bzero(g_workgroup,MAX_BUFF_SIZE); bzero(url,MAX_BUFF_SIZE); bzero(g_print_user,MAX_BUFF_SIZE); bzero(g_print_name,MAX_BUFF_SIZE); g_print_id = 0; g_print_priority = 0; g_print_size = 0; call_back_flag = 0; print_queue_empty = 0; if ( argc == 5 ) { strncpy(g_workgroup,argv[1],strlen(argv[1])); strncpy(g_username,argv[2],strlen(argv[2])); strncpy(g_password,argv[3],strlen(argv[3])); strncpy(url,argv[4],strlen(argv[4])); smbc_init(auth_fn, 0); while ( ! print_queue_empty ) /* Wait until the queue is empty */ { sleep(1); print_queue_empty = 1; smbc_list_print_jobs(url,print_list_fn_2); } smbc_list_print_jobs(url,print_list_fn); if ( call_back_flag ) err = 0; else err = 1; } return err; }
Spider::Spider() : db_name_(), db_server_(), db_user_(), db_password_() { openlog("spider", LOG_CONS | LOG_ODELAY, LOG_USER); mime_type_attr_ = NULL; pserver_manager_ = NULL; result_ = NULL; if (smbc_init(libsmbmm_guest_auth_smbc_get_data, 0) < 0) { DetectError(); MSS_FATAL("smbc_init", error_); return; } // Create a directory to store file headers. if (mkdir(TMPDIR, 00744 /* rwxr--r-- */) && errno != EEXIST) { DetectError(); MSS_ERROR("mkdir", error_); return; } // Prepare to work with libmagic if ((cookie_ = magic_open(MAGIC_MIME_TYPE | MAGIC_ERROR)) == NULL) { error_ = magic_errno(cookie_); MSS_ERROR("magic_open", error_); return; } if (magic_load(cookie_, NULL) == -1) { error_ = magic_errno(cookie_); MSS_ERROR("magic_open", error_); return; } // Allocate memory to the result vector. result_ = new(std::nothrow) std::vector<std::string>(VECTOR_SIZE); if (result_ == NULL) { error_ = ENOMEM; MSS_FATAL("result_", error_); return; } last_ = result_->begin(); error_ = 0; }
static void* smbcfs_init(struct fuse_conn_info *conn) { const int debug_level = 0; const int ret_init = smbc_init(get_auth_data_fn, debug_level); #ifdef SMBCFS_DEBUG fprintf(stderr, "[smbc_init] %p %d => %d\n", get_auth_data_fn, debug_level, ret_init); #endif if(ret_init<0) exit(-ret_init); #ifdef MUTEX_LOCK pthread_mutex_init(&mutex_lock, NULL); #endif return NULL; }