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