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;
}
