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])); smbc_init(auth_fn, 0); fd = smbc_open(url, O_RDWR | O_CREAT, 0666); err = smbc_unlink(url); if ( err < 0 ) err = 1; else err = 0; } return err; }
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; 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 FSSmb::Delete( FSPath& path, int* err, FSCInfo* info ) { FREPARE_SMB_OPER( lock, info, &_param ); int n = smbc_unlink( pathBuffer1.SetPath( path ) ); SetError( err, errno ); return n < 0 ? -1 : n; }
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; }
/***************************************************** a wrapper for unlink() *******************************************************/ int smbw_unlink(const char *fname) { char path[PATH_MAX]; SMBW_INIT(); smbw_fix_path(fname, path); return smbc_unlink(path); }
int smbc_wrapper_unlink(connection* con, const char *furl) { if(con->mode== SMB_BASIC) return smbc_unlink(furl); else if(con->mode == SMB_NTLM) return smbc_cli_unlink(con->smb_info->cli, furl, 0); return -1; }
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; 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; }
bool CFile::Delete(const CURL& url) { smb.Init(); CStdString strFile = GetAuthenticatedPath(url); CLockObject lock(smb); int result = smbc_unlink(strFile.c_str()); if(result != 0) XBMC->Log(LOG_ERROR, "%s - Error( %s )", __FUNCTION__, strerror(errno)); return (result == 0); }
bool Delete(VFSURL* url) { CSMB2::Get().Init(); std::string strFile = GetAuthenticatedPath(url); PLATFORM::CLockObject lock(CSMB2::Get()); int result = smbc_unlink(strFile.c_str()); if(result != 0) XBMC->Log(ADDON::LOG_ERROR, "%s - Error( %s )", __FUNCTION__, strerror(errno)); return (result == 0); }
int SMB_del(char *url, int index) { SMB_init(index); int res = 0; int dh = 0; dh = smbc_opendir(url); printf("SMB_del() - dh = %d\n", dh); if(dh < 0){ res = smbc_unlink(url); } else{ struct smbc_dirent* dirptr; if(url[strlen(url) - 1] != '/') strcat(url, "/"); while((dirptr = smbc_readdir(dh)) != NULL){ if(!strcmp(dirptr->name, ".") || !strcmp(dirptr->name, "..")) continue; char new_url[255] = {0}; sprintf(new_url, "%s%s", url, dirptr->name); printf("-------%s\n", new_url); if(dirptr->smbc_type == SMBC_DIR) { if(new_url[strlen(new_url) - 1] != '/') strcat(new_url, "/"); SMB_del(new_url, index); } else if(dirptr->smbc_type == SMBC_FILE) { res = smbc_unlink(new_url); } } res = smbc_rmdir(url);//删除成功返回0,失败返回-1 } smbc_closedir(dh); return res; }
int FileRemove( const char *file ) { char *ptr; int c; if( (ptr = strchr( file, ':' )) == NULL ) { #ifdef _DEBUG printf("FileRemove : Invalid Path (ptr = NULL)\n"); #endif return -1; } c = ptr - file; if( !strncmp( file, "pfs", 3 ) ) { return fileXioRemove( file ); } else if( !strncmp( file, "mc0:", c ) || !strncmp( file, "mc1:", c ) ) { // there's a bug in the fio stuff that creates a new directory // whenever a file is removed with fioRemove. c = fioRemove( file ); fioRmdir( file ); return c; } else if( !strncmp( file, "mass:", c ) ) { char strDir[256]; c = fioRemove( file ); // you MUST call fioRmdir with device number for USB device. strcpy( strDir, "mass0" ); strcat( strDir, ptr ); // need to remove trailing '/' or fioRmdir won't work if( strDir[ strlen(strDir) - 1 ] == '/' ) strDir[ strlen(strDir) - 1 ] = 0x0; fioRmdir( strDir ); return c; } else if( !strncmp( file, "smb:", c ) ) { return smbc_unlink( file ); } return -1; }
int main(int argc, char** argv) { int err = -1; int fd = 0; int msg_len = 0; char url[MAX_BUFF_SIZE]; char* message = NULL; 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); msg_len = 10; fd = smbc_open(url, O_RDWR, 0666); err = smbc_write(fd, message, msg_len); smbc_close(fd); free(message); if ( err < 0 ) err = 1; else err = 0; } return err; }
//=========================================================================== void SMBSlave::del( const QUrl &kurl, bool isfile) { qCDebug(KIO_SMB) << kurl; m_current_url = kurl; int errNum = 0; int retVal = 0; if(isfile) { // Delete file qCDebug(KIO_SMB) << kurl; retVal = smbc_unlink(m_current_url.toSmbcUrl()); if ( retVal < 0 ){ errNum = errno; } else { errNum = 0; } } else { qCDebug(KIO_SMB) << kurl; // Delete directory retVal = smbc_rmdir(m_current_url.toSmbcUrl()); if( retVal < 0 ) { errNum = errno; } else { errNum = 0; } } if( errNum != 0 ) { reportError(kurl, errNum); } else { finished(); } }
int FileRmdir( const char *path ) { char *ptr; int c; if( (ptr = strchr( path, ':' )) == NULL ) { #ifdef _DEBUG printf("FileRmdir : Invalid Path (ptr = NULL)\n"); #endif return -1; } c = ptr - path; if( !strncmp( path, "pfs", 3 ) ) { return fileXioRmdir( path ); } else if( !strncmp( path, "mc0:", c ) || !strncmp( path, "mc1:", c ) ) { return fioRmdir( path ); } else if( !strncmp( path, "mass:", c ) ) { char strDir[256]; // you MUST call fioRmdir with device number for USB device. strcpy( strDir, "mass0" ); strcat( strDir, ptr ); // need to remove trailing '/' or fioRmdir won't work if( strDir[ strlen(strDir) - 1 ] == '/' ) strDir[ strlen(strDir) - 1 ] = 0x0; return fioRmdir( strDir ); } else if( !strncmp( path, "smb:", c ) ) { return smbc_unlink( path ); } return -1; }
static int smbcfs_unlink(const char* const path) { const std::string smbcfs_path = smbcfs_root_path + path; #ifdef MUTEX_LOCK pthread_mutex_lock(&mutex_lock); #endif const int ret_unlink = smbc_unlink(smbcfs_path.c_str()); #ifdef MUTEX_LOCK pthread_mutex_unlock(&mutex_lock); #endif #ifdef SMBCFS_DEBUG fprintf(stderr, "[smbc_unlink] %s => %d\n", smbcfs_path.c_str(), ret_unlink); #endif return ret_unlink; }
void SMBSlave::smbCopyPut(const QUrl& ksrc, const QUrl& kdst, int permissions, KIO::JobFlags flags) { qCDebug(KIO_SMB) << "src = " << ksrc << ", dest = " << kdst; QFile srcFile (ksrc.toLocalFile()); const QFileInfo srcInfo (srcFile); if (srcInfo.exists()) { if (srcInfo.isDir()) { error(KIO::ERR_IS_DIRECTORY, ksrc.toDisplayString()); return; } } else { error(KIO::ERR_DOES_NOT_EXIST, ksrc.toDisplayString()); return; } if (!srcFile.open(QFile::ReadOnly)) { qCDebug(KIO_SMB) << "could not read from" << ksrc; switch (srcFile.error()) { case QFile::PermissionsError: error(KIO::ERR_WRITE_ACCESS_DENIED, ksrc.toDisplayString()); break; case QFile::OpenError: default: error(KIO::ERR_CANNOT_OPEN_FOR_READING, ksrc.toDisplayString()); break; } return; } totalSize(static_cast<filesize_t>(srcInfo.size())); bool bResume = false; bool bPartExists = false; const bool bMarkPartial = config()->readEntry("MarkPartial", true); const SMBUrl dstOrigUrl (kdst); if (bMarkPartial) { const int errNum = cache_stat(dstOrigUrl.partUrl(), &st); bPartExists = (errNum == 0); if (bPartExists) { if (!(flags & KIO::Overwrite) && !(flags & KIO::Resume)) { bResume = canResume(st.st_size); } else { bResume = (flags & KIO::Resume); } } } int dstfd = -1; int errNum = cache_stat(dstOrigUrl, &st); if (errNum == 0 && !(flags & KIO::Overwrite) && !(flags & KIO::Resume)) { if (S_ISDIR(st.st_mode)) { error( KIO::ERR_IS_DIRECTORY, dstOrigUrl.toDisplayString()); } else { error( KIO::ERR_FILE_ALREADY_EXIST, dstOrigUrl.toDisplayString()); } return; } KIO::filesize_t processed_size = 0; const SMBUrl dstUrl(bMarkPartial ? dstOrigUrl.partUrl() : dstOrigUrl); if (bResume) { // append if resuming qCDebug(KIO_SMB) << "resume" << dstUrl; dstfd = smbc_open(dstUrl.toSmbcUrl(), O_RDWR, 0 ); if (dstfd < 0) { errNum = errno; } else { const off_t offset = smbc_lseek(dstfd, 0, SEEK_END); if (offset == (off_t)-1) { error(KIO::ERR_COULD_NOT_SEEK, dstUrl.toDisplayString()); smbc_close(dstfd); return; } else { processed_size = offset; } } } else { mode_t mode; if (permissions == -1) { mode = 600; } else { mode = permissions | S_IRUSR | S_IWUSR; } qCDebug(KIO_SMB) << "NO resume" << dstUrl; dstfd = smbc_open(dstUrl.toSmbcUrl(), O_CREAT | O_TRUNC | O_WRONLY, mode); if (dstfd < 0) { errNum = errno; } } if (dstfd < 0) { if (errNum == EACCES) { qCDebug(KIO_SMB) << "access denied"; error( KIO::ERR_WRITE_ACCESS_DENIED, dstUrl.toDisplayString()); } else { qCDebug(KIO_SMB) << "can not open for writing"; error( KIO::ERR_CANNOT_OPEN_FOR_WRITING, dstUrl.toDisplayString()); } return; } bool isErr = false; if (processed_size == 0 || srcFile.seek(processed_size)) { // Perform the copy char buf[MAX_XFER_BUF_SIZE]; while (1) { const ssize_t bytesRead = srcFile.read(buf, MAX_XFER_BUF_SIZE); if (bytesRead <= 0) { if (bytesRead < 0) { error(KIO::ERR_COULD_NOT_READ, ksrc.toDisplayString()); isErr = true; } break; } const qint64 bytesWritten = smbc_write(dstfd, buf, bytesRead); if (bytesWritten == -1) { error(KIO::ERR_COULD_NOT_WRITE, kdst.toDisplayString()); isErr = true; break; } processed_size += bytesWritten; processedSize(processed_size); } } else { isErr = true; error(KIO::ERR_COULD_NOT_SEEK, ksrc.toDisplayString()); } // FINISHED if (smbc_close(dstfd) < 0) { qCDebug(KIO_SMB) << dstUrl << "could not write"; error( KIO::ERR_COULD_NOT_WRITE, dstUrl.toDisplayString()); return; } // Handle error condition. if (isErr) { if (bMarkPartial) { const int size = config()->readEntry("MinimumKeepSize", DEFAULT_MINIMUM_KEEP_SIZE); const int errNum = cache_stat(dstUrl, &st); if (errNum == 0 && st.st_size < size) { smbc_unlink(dstUrl.toSmbcUrl()); } } return; } // Rename partial file to its original name. if (bMarkPartial) { smbc_unlink(dstOrigUrl.toSmbcUrl()); if (smbc_rename(dstUrl.toSmbcUrl(), dstOrigUrl.toSmbcUrl()) < 0) { qCDebug(KIO_SMB) << "failed to rename" << dstUrl << "to" << dstOrigUrl << "->" << strerror(errno); error(ERR_CANNOT_RENAME_PARTIAL, dstUrl.toDisplayString()); return; } } #ifdef HAVE_UTIME_H // set modification time const QString mtimeStr = metaData( "modified" ); if (!mtimeStr.isEmpty() ) { QDateTime dt = QDateTime::fromString( mtimeStr, Qt::ISODate ); if ( dt.isValid() ) { struct utimbuf utbuf; utbuf.actime = st.st_atime; // access time, unchanged utbuf.modtime = dt.toTime_t(); // modification time smbc_utime( dstUrl.toSmbcUrl(), &utbuf ); } } #endif // We have done our job => finish finished(); }
int main(int argc, char *argv[]) { int err, fd, dh1, dsize, dirc; const char *file = "smb://samba/public/testfile.txt"; const char *file2 = "smb://samba/public/testfile2.txt"; char buff[256]; char dirbuf[512]; char *dirp; struct stat st1, st2; err = smbc_init(get_auth_data_fn, 10); /* Initialize things */ if (err < 0) { fprintf(stderr, "Initializing the smbclient library ...: %s\n", strerror(errno)); } if (argc > 1) { if ((dh1 = smbc_opendir(argv[1]))<1) { fprintf(stderr, "Could not open directory: %s: %s\n", argv[1], strerror(errno)); exit(1); } fprintf(stdout, "Directory handle: %u\n", dh1); /* Now, list those directories, but in funny ways ... */ dirp = (char *)dirbuf; if ((dirc = smbc_getdents(dh1, (struct smbc_dirent *)dirp, sizeof(dirbuf))) < 0) { fprintf(stderr, "Problems getting directory entries: %s\n", strerror(errno)); exit(1); } /* Now, process the list of names ... */ fprintf(stdout, "Directory listing, size = %u\n", dirc); while (dirc > 0) { dsize = ((struct smbc_dirent *)dirp)->dirlen; fprintf(stdout, "Dir Ent, Type: %u, Name: %s, Comment: %s\n", ((struct smbc_dirent *)dirp)->smbc_type, ((struct smbc_dirent *)dirp)->name, ((struct smbc_dirent *)dirp)->comment); dirp += dsize; dirc -= dsize; } dirp = (char *)dirbuf; exit(1); } /* For now, open a file on a server that is hard coded ... later will * read from the command line ... */ fd = smbc_open(file, O_RDWR | O_CREAT | O_TRUNC, 0666); if (fd < 0) { fprintf(stderr, "Creating file: %s: %s\n", file, strerror(errno)); exit(0); } fprintf(stdout, "Opened or created file: %s\n", file); /* Now, write some date to the file ... */ memset(buff, '\0', sizeof(buff)); snprintf(buff, sizeof(buff), "%s", "Some test data for the moment ..."); err = smbc_write(fd, buff, sizeof(buff)); if (err < 0) { fprintf(stderr, "writing file: %s: %s\n", file, strerror(errno)); exit(0); } fprintf(stdout, "Wrote %lu bytes to file: %s\n", (unsigned long) sizeof(buff), buff); /* Now, seek the file back to offset 0 */ err = smbc_lseek(fd, SEEK_SET, 0); if (err < 0) { fprintf(stderr, "Seeking file: %s: %s\n", file, strerror(errno)); exit(0); } fprintf(stdout, "Completed lseek on file: %s\n", file); /* Now, read the file contents back ... */ err = smbc_read(fd, buff, sizeof(buff)); if (err < 0) { fprintf(stderr, "Reading file: %s: %s\n", file, strerror(errno)); exit(0); } fprintf(stdout, "Read file: %s\n", buff); /* Should check the contents */ fprintf(stdout, "Now fstat'ing file: %s\n", file); err = smbc_fstat(fd, &st1); if (err < 0) { fprintf(stderr, "Fstat'ing file: %s: %s\n", file, strerror(errno)); exit(0); } /* Now, close the file ... */ err = smbc_close(fd); if (err < 0) { fprintf(stderr, "Closing file: %s: %s\n", file, strerror(errno)); } /* Now, rename the file ... */ err = smbc_rename(file, file2); if (err < 0) { fprintf(stderr, "Renaming file: %s to %s: %s\n", file, file2, strerror(errno)); } fprintf(stdout, "Renamed file %s to %s\n", file, file2); /* Now, create a file and delete it ... */ fprintf(stdout, "Now, creating file: %s so we can delete it.\n", file); fd = smbc_open(file, O_RDWR | O_CREAT, 0666); if (fd < 0) { fprintf(stderr, "Creating file: %s: %s\n", file, strerror(errno)); exit(0); } fprintf(stdout, "Opened or created file: %s\n", file); err = smbc_close(fd); if (err < 0) { fprintf(stderr, "Closing file: %s: %s\n", file, strerror(errno)); exit(0); } /* Now, delete the file ... */ fprintf(stdout, "File %s created, now deleting ...\n", file); err = smbc_unlink(file); if (err < 0) { fprintf(stderr, "Deleting file: %s: %s\n", file, strerror(errno)); exit(0); } /* Now, stat the file, file 2 ... */ fprintf(stdout, "Now stat'ing file: %s\n", file); err = smbc_stat(file2, &st2); if (err < 0) { fprintf(stderr, "Stat'ing file: %s: %s\n", file, strerror(errno)); exit(0); } fprintf(stdout, "Stat'ed file: %s. Size = %d, mode = %04X\n", file2, (int)st2.st_size, (unsigned int)st2.st_mode); fprintf(stdout, " time: %s\n", ctime(&st2.st_atime)); fprintf(stdout, "Earlier stat: %s, Size = %d, mode = %04X\n", file, (int)st1.st_size, (unsigned int)st1.st_mode); fprintf(stdout, " time: %s\n", ctime(&st1.st_atime)); /* Now, make a directory ... */ fprintf(stdout, "Making directory smb://samba/public/make-dir\n"); if (smbc_mkdir("smb://samba/public/make-dir", 0666) < 0) { fprintf(stderr, "Error making directory: smb://samba/public/make-dir: %s\n", strerror(errno)); if (errno == EEXIST) { /* Try to delete the directory */ fprintf(stdout, "Trying to delete directory: smb://samba/public/make-dir\n"); if (smbc_rmdir("smb://samba/public/make-dir") < 0) { /* Error */ fprintf(stderr, "Error removing directory: smb://samba/public/make-dir: %s\n", strerror(errno)); exit(0); } fprintf(stdout, "Making directory: smb://samba/public/make-dir\n"); if (smbc_mkdir("smb://samba/public/make-dir", 666) < 0) { fprintf(stderr, "Error making directory: smb://samba/public/make-dir: %s\n", strerror(errno)); fprintf(stderr, "I give up!\n"); exit(1); } } exit(0); } fprintf(stdout, "Made dir: make-dir\n"); return 0; }
int main(int argc, char** argv) { int err = -1; int fd = 0; unsigned int i = 0; int msg_len = 0; char url[MAX_BUFF_SIZE]; char* message; memset(g_workgroup, '\0', MAX_BUFF_SIZE); memset(url, '\0', MAX_BUFF_SIZE); memset(g_print_user, '\0', MAX_BUFF_SIZE); memset(g_print_name, '\0', MAX_BUFF_SIZE); g_print_id = 0; g_print_priority = 0; g_print_size = 0; print_id_count = 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_print_file(url,argv[6]); smbc_print_file(url,argv[6]); smbc_list_print_jobs(argv[6],print_list_fn); if ( smbc_unlink_print_job(argv[6],g_print_id) == 0 ) { if ( smbc_list_print_jobs(argv[6],print_list_fn_2) == 0 ) { err = 0; for ( i=0; i<print_id_count; i++ ) { if ( g_print_id == print_ids[i] ) { err = 1; break; } } } } else err = 1; } return err; }
static int _unlink(const char *uri) { return smbc_unlink(uri); }