int FileWrite( FHANDLE handle, void *buffer, int size )
{
int ret = 0;
if( handle.dt == DT_CD ) {
ret = fioWrite( handle.fh, buffer, size );
}
else if( handle.dt == DT_HDD ) {
ret = fileXioWrite( handle.fh, buffer, size );
}
else if( handle.dt == DT_MC ) {
ret = fioWrite( handle.fh, buffer, size );
}
else if( handle.dt == DT_USB ) {
ret = fioWrite( handle.fh, buffer, size );
}
else if( handle.dt == DT_HOST ) {
ret = fioWrite( handle.fh, buffer, size );
}
else if( handle.dt == DT_SMB_SHARE ) {
ret = smbc_write( handle.fh, buffer, size );
}
return ret;
}
/*****************************************************
a wrapper for pwrite()
*******************************************************/
ssize_t smbw_pwrite(int smbw_fd, void *buf, size_t count, SMBW_OFF_T ofs)
{
int saved_errno;
int client_fd;
ssize_t ret;
SMBW_OFF_T old_ofs;
if (count == 0) {
return 0;
}
client_fd = smbw_fd_map[smbw_fd];
if ((old_ofs = smbc_lseek(client_fd, 0, SEEK_CUR)) < 0 ||
smbc_lseek(client_fd, ofs, SEEK_SET) < 0) {
return -1;
}
if ((ret = smbc_write(client_fd, buf, count)) < 0) {
saved_errno = errno;
(void) smbc_lseek(client_fd, old_ofs, SEEK_SET);
errno = saved_errno;
return -1;
}
return ret;
}
int main(int argc, char** argv)
{
int err = -1;
int fd = 0;
char* message = "Testing";
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]));
fd = 10345; /* Random value for File Descriptor */
smbc_init(auth_fn, 0);
err = smbc_write(fd, message, sizeof(message));
if ( err < 0 )
err = 1;
else
err = 0;
}
return err;
}
int main(int argc, char* argv[])
{
int ret = -1, lock_fd = -1, errcode = -1;
int ifd = -1, ofd = -1, isize = 0;
struct SMB_DS ds;
char* ifptr = NULL, *ofilename;
NE_ERR(argc, 2);
lock_fd = lock_smb_fd("/var/lock/smbc_put.lock");EQ_ERR(lock_fd, -1);
ret = SMB_BULK_ReadDS(&ds);EQ_ERR(ret, -1);
EQ_ERR(ds.enable, 0);
ofilename = strrchr(argv[1], '/');EQ_ERR(ofilename, NULL);
ifd = get_vlog_fd(argv[1], &ifptr, &isize);EQ_ERR(ifd, -1);
ofd = get_smb_server_fd(&ds, ofilename+1);EQ_ERR_ERRCODE(ofd, -1, errno);
ret = smbc_write(ofd, ifptr, isize);NE_ERR_ERRCODE(ret, isize, errno);
errcode = 0;
errout:
if(ifd != -1)
close(ifd);
if(ofd != -1)
smbc_close(ofd);
return errcode;
}
/*****************************************************
a wrapper for write()
*******************************************************/
ssize_t smbw_write(int smbw_fd, void *buf, size_t count)
{
int client_fd;
client_fd = smbw_fd_map[smbw_fd];
return smbc_write(client_fd, buf, count);
}
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;
}
size_t smbc_wrapper_write(connection* con, int fd, const void *buf, size_t bufsize, uint16_t write_mode )
{
if(con->mode== SMB_BASIC)
return smbc_write(fd, buf, bufsize);
else if(con->mode == SMB_NTLM)
return smbc_cli_write(con->smb_info->cli, fd, write_mode, buf, bufsize);
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;
}
/* upload file */
int SMB_upload(char *localpath, int index)
{
if(access(localpath, F_OK) != 0)
{
printf("Local has no %s\n", localpath);
return LOCAL_FILE_LOST;
}
write_log(S_UPLOAD, "", localpath, index);
SMB_init(index);
int buflen;
char buffer[4096] = {0};
char *serverpath = localpath_to_serverpath(localpath, index);
int smb_fd = smbc_open(serverpath, O_RDWR|O_CREAT, FILE_MODE);
int cli_fd;
if((cli_fd = open(localpath, O_RDONLY, FILE_MODE)) > 0)
{//以只读的方式打开，文件
DEBUG("open localpath sucess\n");
unsigned long long cli_filesize = 0;
unsigned long long smb_filesize = 0;
cli_filesize = lseek(cli_fd, 0L, SEEK_END);
lseek(cli_fd, 0L, SEEK_SET);//read or write 文件的偏移量
//2014.11.19 by sherry 判断上传是否成功
//buflen = read(cli_fd, buffer, sizeof(buffer));
//DEBUG("buflen=%d\n",buflen);
//while(buflen > 0 && exit_loop == 0)
while((buflen = read(cli_fd, buffer, sizeof(buffer))) > 0 && exit_loop == 0)
{
smb_filesize += buflen;
//2014.11.19 by sherry 判断上传是否成功
//smbc_write(smb_fd, buffer, buflen);//smb_fd为server端的文件
int res=0;
res=smbc_write(smb_fd, buffer, buflen);
if(res==-1)
return -1;
printf("\rUpload [%s] percent - %f ", localpath, (float)smb_filesize/(float)cli_filesize);
}
if(smb_filesize != cli_filesize && exit_loop != 0)
{
DEBUG("smb_filesize != cli_filesize && exit_loop != 0");
FILE *f_stream = fopen(g_pSyncList[index]->up_item_file, "w");
fprintf(f_stream, "%s", localpath);
fclose(f_stream);
}
smbc_close(smb_fd);
close(cli_fd);
DEBUG("upload --end\n");
}
free(serverpath);
return 0;
}
int FSSmb::Write( int fd, void* buf, int size, int* err, FSCInfo* info )
{
FREPARE_SMB_OPER( lock, info, &_param );
int n = smbc_write( fd, buf, size );
if ( n < 0 ) { SetError( err, errno ); return -1; }
return n;
}
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 int write_buffer(stream_t *s, char* buffer, int len) {
int r;
int wr = 0;
while (wr < len) {
r = smbc_write(s->fd,buffer,len);
if (r <= 0)
return -1;
wr += r;
buffer += r;
}
return len;
}
int CFile::Write(const void* lpBuf, int64_t uiBufSize)
{
if (m_fd == -1) return -1;
DWORD dwNumberOfBytesWritten = 0;
// lpBuf can be safely casted to void* since xmbc_write will only read from it.
smb.Init();
CLockObject lock(smb);
dwNumberOfBytesWritten = smbc_write(m_fd, (void*)lpBuf, (DWORD)uiBufSize);
return (int)dwNumberOfBytesWritten;
}
static ssize_t _write(csync_vio_method_handle_t *fhandle, const void *buf, size_t count) {
smb_fhandle_t *handle = NULL;
if (fhandle == NULL) {
errno = EBADF;
return (ssize_t) -1;
}
handle = (smb_fhandle_t *) fhandle;
return smbc_write(handle->fd, (char *) buf, count);
}
int Write(void* context, const void* lpBuf, int64_t uiBufSize)
{
SMBContext* ctx = (SMBContext*)context;
if (ctx->fd == -1)
return -1;
int dwNumberOfBytesWritten = 0;
// lpBuf can be safely casted to void* since xmbc_write will only read from it.
CSMB2::Get().Init();
PLATFORM::CLockObject lock(CSMB2::Get());
dwNumberOfBytesWritten = smbc_write(ctx->fd, (void*)lpBuf, uiBufSize);
return (int)dwNumberOfBytesWritten;
}
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;
}
/* upload file */
int SMB_upload(char *localpath, int index)
{
if(access(localpath, F_OK) != 0)
{
printf("Local has no %s\n", localpath);
return LOCAL_FILE_LOST;
}
write_log(S_UPLOAD, "", localpath, index);
SMB_init(index);
int buflen;
char buffer[4096] = {0};
char *serverpath = localpath_to_serverpath(localpath, index);
int smb_fd = smbc_open(serverpath, O_RDWR|O_CREAT, FILE_MODE);
int cli_fd;
if((cli_fd = open(localpath, O_RDONLY, FILE_MODE)) > 0){
unsigned long long cli_filesize = 0;
unsigned long long smb_filesize = 0;
cli_filesize = lseek(cli_fd, 0L, SEEK_END);
lseek(cli_fd, 0L, SEEK_SET);
while((buflen = read(cli_fd, buffer, sizeof(buffer))) > 0 && exit_loop == 0){
smb_filesize += buflen;
smbc_write(smb_fd, buffer, buflen);
printf("\rUpload [%s] percent - %f ", localpath, (float)smb_filesize/(float)cli_filesize);
}
if(smb_filesize != cli_filesize && exit_loop != 0)
{
FILE *f_stream = fopen(g_pSyncList[index]->up_item_file, "w");
fprintf(f_stream, "%s", localpath);
fclose(f_stream);
}
smbc_close(smb_fd);
close(cli_fd);
}
free(serverpath);
return 0;
}
static int smbcfs_write(const char* const path, const char* const buf, const std::size_t size, const off_t offset, struct fuse_file_info* const fi)
{
const int fh = fi->fh;
#ifdef MUTEX_LOCK
pthread_mutex_lock(&mutex_lock);
#endif
const int ret_lseek = smbc_lseek(fh, offset, SEEK_SET);
#ifdef MUTEX_LOCK
pthread_mutex_unlock(&mutex_lock);
#endif
#ifdef SMBCFS_DEBUG
fprintf(stderr, "[smbc_lseek] %d %lld %d => %d\n",
fh, offset, SEEK_SET, ret_lseek);
#endif
if(ret_lseek<0) { return ret_lseek; }
#ifdef MUTEX_LOCK
pthread_mutex_lock(&mutex_lock);
#endif
const int ret_write = smbc_write(fh, (void*)buf, size);
#ifdef MUTEX_LOCK
pthread_mutex_unlock(&mutex_lock);
#endif
#ifdef SMBCFS_DEBUG
fprintf(stderr, "[smbc_write] %d %p %ld => %d\n",
fh, buf, size, ret_write);
#endif
return ret_write;
}
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();
}
static void generate_files()
{
/* on playback, load the number of files */
if (config.replay!=NULL) {
fscanf(config.player,"number of files: %i\n",&config.number);
}
int list[config.number];
int i,z;
int fd, fd2;
int bytecount;
int debug=0;
char buffer[40000];
srand(time(NULL) + getpid());
for(i=0;i<config.number;i++)
{
list[i]=(rand() % (config.size-(config.number-i)));
config.size=config.size-list[i];
}
list[config.number-1]=config.size;
/* when recording, store the list of files and sizes */
if (config.record!=NULL) {
/* when recording, store the time to wait here */
fprintf(config.recorder,"number of files: %i\n",config.number);
for (z=0;z<config.number;z++) {
fprintf(config.recorder,"file size: %i\n",list[z]);
}
}
/* on playback, load the list of files and sizes */
if (config.replay!=NULL) {
for (z=0;z<config.number;z++) {
fscanf(config.player,"file size: %i\n",&list[z]);
}
}
if (config.verbose == 1)
{
printf("Stage 1: creating now the files on both shares\n");
}
for (i=0;i<config.number;i++) {
char *t = NULL;
if (config.replay == NULL) t = get_random_filename();
if (config.replay != NULL) {
fscanf(config.player,"Filename: %ms\n",&t);
}
char *Dateiname1 = (char *) malloc(sizeof(char) * (strlen(config.share1)+strlen(t)+5));
char *Dateiname2 = (char *) malloc(sizeof(char) * (strlen(config.share2)+strlen(t)+5));
/* when recording, write the list of filenames + paths */
if (config.record!=NULL) {
fprintf(config.recorder,"Filename: %s\n", t);
}
strcpy(Dateiname1,config.share1);
strcpy(Dateiname2,config.share2);
strcat(Dateiname1,t);
strcat(Dateiname2,t);
fnamelist[i]=t;
// create directories
smbc_init(get_auth_data_fn, debug);
int z= 0;
char *sname = (char *) malloc(sizeof(char) * (strlen(config.share1)+strlen(t)+5 + strlen(config.share2)));
while (z<strlen(t)) {
if (t[z]=='/') {
t[z]='\0';
strcpy(sname,config.share1);
strcat(sname,t);
printf("Creating Directory: %s\n",sname);
smbc_mkdir(sname,0777);
strcpy(sname,config.share2);
strcat(sname,t);
printf("Creating Directory: %s\n",sname);
smbc_mkdir(sname,0777);
t[z]='/';
}
z++;
}
free(sname);
if ((fd = smbc_open(Dateiname1,
O_WRONLY | O_CREAT | O_TRUNC, 0)) < 0)
{
perror("smbc_open: writing failed");
}
bytecount=list[i];
while (bytecount>40000) {
smbc_write( fd,buffer,40000);
bytecount=bytecount-40000;
}
if (bytecount<40000) {
smbc_write(fd,buffer,bytecount);
bytecount=0;
}
smbc_close(fd);
if ((fd2 = smbc_open(Dateiname2,
O_WRONLY | O_CREAT | O_TRUNC, 0) < 0))
{
perror("smbc_open: failed");
exit(1);
}
bytecount=list[i];
while (bytecount>40000) {
smbc_write(fd, buffer, 40000);
bytecount=bytecount-40000;
}
if (bytecount<40000) {
smbc_write(fd, buffer, bytecount),
bytecount=0;
}
if(config.verbose==1)
{
printf("File %s written with %u Bytes\n", Dateiname1, list[i]);
}
if(i==config.number-1)
{
printf("All files successfully written."
" Now it's torture time!\n");
}
smbc_close(fd2);
free(Dateiname1);
free(Dateiname2);
}
}
static void copy()
{
int fd, fd2;
int ret;
int i;
int debug=0;
int rTime,justread;
char buffer[40048];
i=( random() % config.number);
char *Dateiname1;
char *Dateiname2;
rTime= (random() % 2);
justread= (random() %2); // wether to write to the target share or not
/* at this point we have the full filenames. In case of
* recording, we save them here. In case of replay, we
* replace them with the strings from the file.
*/
if (config.record!=NULL) {
fprintf(config.recorder,"file1: %i\n",i);
fprintf(config.recorder,"file2: %i\n",i);
fprintf(config.recorder,"just read: %i\n",justread);
}
if (config.replay!=NULL) {
fscanf(config.player,"file1: %i\n",&i);
fscanf(config.player,"file2: %i\n",&i);
fscanf(config.player,"just read: %i\n",&justread);
}
Dateiname1 = (char *) malloc(sizeof(char) * (strlen(config.share1)+strlen(config.share2)+strlen(fnamelist[i])));
Dateiname2 = (char *) malloc(sizeof(char) * (strlen(config.share1)+strlen(config.share2)+strlen(fnamelist[i])));
switch (rTime)
{
case 0:
strcpy(Dateiname1, config.share1);
strcpy(Dateiname2, config.share2);
break;
case 1:
strcpy(Dateiname1, config.share2);
strcpy(Dateiname2, config.share1);
break;
}
strcat(Dateiname1, fnamelist[i]);
strcat(Dateiname2, fnamelist[i]);
smbc_init(get_auth_data_fn, debug);
if ((fd = smbc_open(Dateiname1, O_RDONLY, 0)) < 0)
{
perror("smbc_open failed");
exit(1);
}
if (justread!=1 && (fd2 = smbc_open(Dateiname2,
O_WRONLY | O_CREAT | O_TRUNC, 0)) < 0)
{
perror("smbc_open: writing failed");
exit(1);
}
do
{
ret = smbc_read(fd, buffer, sizeof(buffer));
if (ret > 0 && justread!=1) smbc_write(fd2, buffer, ret);
} while (ret > 0);
smbc_close(fd);
if (justread!=1) smbc_close(fd2);
if (config.time==0) rTime=0;
else
rTime = (random() % config.time)+1;
if (config.record!=NULL) {
/* when recording, store the time to wait here */
fprintf(config.recorder,"wait: %i\n",rTime);
}
if (config.replay!=NULL) {
/* when in playback, load the time to wait here */
fscanf(config.player,"wait: %i\n",&rTime);
}
if(config.verbose == 1)
{ if (justread!=1) printf("File %s copied to %s\n", Dateiname1, Dateiname2);
else printf("Read file %s into memory.\n",Dateiname1);
printf("Sleeping %i seconds...\n", rTime);
}
sleep(rTime);
free(Dateiname1);
free(Dateiname2);
if (config.verbose ==1) printf("Transferring data...\n");
}
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;
}
static int write_buffer(stream_t *s, char* buffer, int len) {
int r = smbc_write(s->fd,buffer,len);
return (r <= 0) ? -1 : r;
}
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;
}
//===========================================================================
void SMBSlave::put( const KURL& kurl,
int permissions,
bool overwrite,
bool resume )
{
void *buf;
size_t bufsize;
m_current_url = kurl;
int filefd;
bool exists;
mode_t mode;
QByteArray filedata;
kdDebug(KIO_SMB) << "SMBSlave::put on " << kurl << endl;
exists = (cache_stat(m_current_url, &st) != -1 );
if ( exists && !overwrite && !resume)
{
if (S_ISDIR(st.st_mode))
{
kdDebug(KIO_SMB) << "SMBSlave::put on " << kurl <<" already isdir !!"<< endl;
error( KIO::ERR_DIR_ALREADY_EXIST, m_current_url.prettyURL());
}
else
{
kdDebug(KIO_SMB) << "SMBSlave::put on " << kurl <<" already exist !!"<< endl;
error( KIO::ERR_FILE_ALREADY_EXIST, m_current_url.prettyURL());
}
return;
}
if (exists && !resume && overwrite)
{
kdDebug(KIO_SMB) << "SMBSlave::put exists try to remove " << m_current_url.toSmbcUrl()<< endl;
// remove(m_current_url.url().local8Bit());
}
if (resume)
{
// append if resuming
kdDebug(KIO_SMB) << "SMBSlave::put resume " << m_current_url.toSmbcUrl()<< endl;
filefd = smbc_open(m_current_url.toSmbcUrl(), O_RDWR, 0 );
smbc_lseek(filefd, 0, SEEK_END);
}
else
{
if (permissions != -1)
{
mode = permissions | S_IWUSR | S_IRUSR;
}
else
{
mode = 600;//0666;
}
kdDebug(KIO_SMB) << "SMBSlave::put NO resume " << m_current_url.toSmbcUrl()<< endl;
filefd = smbc_open(m_current_url.toSmbcUrl(), O_CREAT | O_TRUNC | O_WRONLY, mode);
}
if ( filefd < 0 )
{
if ( errno == EACCES )
{
kdDebug(KIO_SMB) << "SMBSlave::put error " << kurl <<" access denied !!"<< endl;
error( KIO::ERR_WRITE_ACCESS_DENIED, m_current_url.prettyURL());
}
else
{
kdDebug(KIO_SMB) << "SMBSlave::put error " << kurl <<" can not open for writing !!"<< endl;
error( KIO::ERR_CANNOT_OPEN_FOR_WRITING, m_current_url.prettyURL());
}
finished();
return;
}
// Loop until we got 0 (end of data)
while(1)
{
kdDebug(KIO_SMB) << "SMBSlave::put request data "<< endl;
dataReq(); // Request for data
kdDebug(KIO_SMB) << "SMBSlave::put write " << m_current_url.toSmbcUrl()<< endl;
if (readData(filedata) <= 0)
{
kdDebug(KIO_SMB) << "readData <= 0" << endl;
break;
}
kdDebug(KIO_SMB) << "SMBSlave::put write " << m_current_url.toSmbcUrl()<< endl;
buf = filedata.data();
bufsize = filedata.size();
int size = smbc_write(filefd, buf, bufsize);
if ( size < 0)
{
kdDebug(KIO_SMB) << "SMBSlave::put error " << kurl <<" could not write !!"<< endl;
error( KIO::ERR_COULD_NOT_WRITE, m_current_url.prettyURL());
finished();
return;
}
kdDebug(KIO_SMB ) << "wrote " << size << endl;
}
kdDebug(KIO_SMB) << "SMBSlave::put close " << m_current_url.toSmbcUrl()<< endl;
if(smbc_close(filefd))
{
kdDebug(KIO_SMB) << "SMBSlave::put on " << kurl <<" could not write !!"<< endl;
error( KIO::ERR_COULD_NOT_WRITE, m_current_url.prettyURL());
finished();
return;
}
// set final permissions, if the file was just created
if ( permissions != -1 && !exists )
{
// TODO: did the smbc_chmod fail?
// TODO: put in call to chmod when it is working!
// smbc_chmod(url.toSmbcUrl(),permissions);
}
// We have done our job => finish
finished();
}
void SMBSlave::smbCopy(const QUrl& ksrc, const QUrl& kdst, int permissions, KIO::JobFlags flags)
{
SMBUrl src;
SMBUrl dst;
mode_t initialmode;
ssize_t n;
int dstflags;
int srcfd = -1;
int dstfd = -1;
int errNum = 0;
KIO::filesize_t processed_size = 0;
unsigned char buf[MAX_XFER_BUF_SIZE];
qCDebug(KIO_SMB) << "SMBSlave::copy with src = " << ksrc << "and dest = " << kdst;
// setup urls
src = ksrc;
dst = kdst;
// Obtain information about source
errNum = cache_stat(src, &st );
if( errNum != 0 )
{
if ( errNum == EACCES )
{
error( KIO::ERR_ACCESS_DENIED, src.toDisplayString());
}
else
{
error( KIO::ERR_DOES_NOT_EXIST, src.toDisplayString());
}
return;
}
if ( S_ISDIR( st.st_mode ) )
{
error( KIO::ERR_IS_DIRECTORY, src.toDisplayString() );
return;
}
totalSize(st.st_size);
// Check to se if the destination exists
errNum = cache_stat(dst, &st);
if( errNum == 0 )
{
if(S_ISDIR(st.st_mode))
{
error( KIO::ERR_DIR_ALREADY_EXIST, dst.toDisplayString());
return;
}
if(!(flags & KIO::Overwrite))
{
error( KIO::ERR_FILE_ALREADY_EXIST, dst.toDisplayString());
return;
}
}
// Open the source file
srcfd = smbc_open(src.toSmbcUrl(), O_RDONLY, 0);
if (srcfd < 0){
errNum = errno;
} else {
errNum = 0;
}
if(srcfd < 0)
{
if(errNum == EACCES)
{
error( KIO::ERR_ACCESS_DENIED, src.toDisplayString() );
}
else
{
error( KIO::ERR_DOES_NOT_EXIST, src.toDisplayString() );
}
return;
}
// Determine initial creation mode
if(permissions != -1)
{
initialmode = permissions | S_IWUSR;
}
else
{
initialmode = 0 | S_IWUSR;//0666;
}
// Open the destination file
dstflags = O_CREAT | O_TRUNC | O_WRONLY;
if(!(flags & KIO::Overwrite))
{
dstflags |= O_EXCL;
}
dstfd = smbc_open(dst.toSmbcUrl(), dstflags, initialmode);
if (dstfd < 0){
errNum = errno;
} else {
errNum = 0;
}
if(dstfd < 0)
{
if(errNum == EACCES)
{
error(KIO::ERR_WRITE_ACCESS_DENIED, dst.toDisplayString());
}
else
{
error(KIO::ERR_CANNOT_OPEN_FOR_READING, dst.toDisplayString());
}
if(srcfd >= 0 )
{
smbc_close(srcfd);
}
return;
}
// Perform copy
while(1)
{
n = smbc_read(srcfd, buf, MAX_XFER_BUF_SIZE );
if(n > 0)
{
n = smbc_write(dstfd, buf, n);
if(n == -1)
{
qCDebug(KIO_SMB) << "SMBSlave::copy copy now KIO::ERR_COULD_NOT_WRITE";
error( KIO::ERR_COULD_NOT_WRITE, dst.toDisplayString());
break;
}
processed_size += n;
processedSize(processed_size);
}
else if(n == 0)
{
break; // finished
}
else
{
error( KIO::ERR_COULD_NOT_READ, src.toDisplayString());
break;
}
}
// FINISHED:
if(srcfd >= 0 )
{
smbc_close(srcfd);
}
if(dstfd >= 0)
{
if(smbc_close(dstfd) == 0)
{
// TODO: set final permissions
}
else
{
error( KIO::ERR_COULD_NOT_WRITE, dst.toDisplayString());
return;
}
}
finished();
}
int main(int argc, char * argv[])
{
int fd;
int ret;
int debug = 0;
int savedErrno;
char buffer[128];
struct stat st;
if (argc != 2)
{
printf("usage: "
"%s smb://path/to/file\n",
argv[0]);
return 1;
}
smbc_init(get_auth_data_fn, debug);
if ((fd = smbc_open(argv[1], O_WRONLY | O_CREAT | O_TRUNC, 0)) < 0)
{
perror("smbc_open");
return 1;
}
strcpy(buffer, "Hello world.\nThis is a test.\n");
ret = smbc_write(fd, buffer, strlen(buffer));
savedErrno = errno;
smbc_close(fd);
if (ret < 0)
{
errno = savedErrno;
perror("write");
}
if (smbc_stat(argv[1], &st) < 0)
{
perror("smbc_stat");
return 1;
}
printf("Original size: %lu\n", (unsigned long) st.st_size);
if ((fd = smbc_open(argv[1], O_WRONLY, 0)) < 0)
{
perror("smbc_open");
return 1;
}
ret = smbc_ftruncate(fd, 13);
savedErrno = errno;
smbc_close(fd);
if (ret < 0)
{
errno = savedErrno;
perror("smbc_ftruncate");
return 1;
}
if (smbc_stat(argv[1], &st) < 0)
{
perror("smbc_stat");
return 1;
}
printf("New size: %lu\n", (unsigned long) st.st_size);
return 0;
}
