/* * Set archive operations. */ int SamrftArchiveOp( SamrftImpl_t *rftd, char *path, const char *ops) { int rc = -1; int error; if (rftd->remotehost) { SendCommand(rftd, "%s %s %s", SAMRFT_CMD_ARCHIVEOP, path, ops); if (GetReply(rftd) >= 0) { rc = GetArchiveOpReply(rftd, &error); if (rc < 0) { SetErrno = error; } } } else { struct sam_fileops_arg arg; arg.path.ptr = path; arg.ops.ptr = ops; rc = sam_syscall(SC_archive, &arg, sizeof (arg)); } return (rc); }
const GetFileListRPC::FileList * GetFileListRPC::operator()(const std::string &f, bool grouping, bool smartGrouping) { debug3 << "Executing GetFileList(" << f.c_str() << (grouping?"true":"false") << ", " << (smartGrouping?"true":"false") << ", " << ") RPC\n"; // Store the arguments. filter = f; automaticFileGrouping = grouping; smartFileGrouping = smartGrouping; // Try to execute the RPC. Execute(); // If the RPC returned an error, throw an exception. if(GetReply()->GetStatus() == error) { EXCEPTION0(GetFileListException); } return &fileList; }
void ReadModule::HandleCommand() { int reply_size = -1; bool state = false; char *reply = GetReply(cmd_socket, state, true, reply_size); if (reply == NULL) return; std::cout << "HandleCommand: " << std::string(reply, reply_size) << std::endl; if (reply_size < 2) std::cerr << "Error: Reply is not large for magic header + command string" << std::endl; char magic_value = reply[0]; reply[reply_size-1] = '\0'; if (magic_value == 0x01) { // connect to command... std::string name = std::string(reply+1); int pos = name.find("->"); if (pos == std::string::npos) { std::cerr << "Error: no -> separator in connect command" << std::endl; return; } std::string source = name.substr(0, pos); std::string target = name.substr(pos+2); // todo: std::cout << "Connect from " << source << " to " << target << std::endl; Connect(source, target); } else { std::cerr << "Error: Unknown command!" << std::endl; } SendAck(cmd_socket, true); delete [] reply; }
void CFtpDialog::ChangeDirectory() { if (fSocket < 0) { beep(); return; } try { s_printf(fSocketFD, "cwd %s\r\n", fPath); GetReply(); if (*fReply != '2') THROW(("Changing directory failed.\n%s", fReply)); ListDirectory(); } catch (HErr& err) { err.DoError(); } GetPWD(); } // CFtpDialog::ChangeDirectory
/* * Make directory on remote host. */ int SamrftMkdir( SamrftImpl_t *rftd, char *dirname, SamrftCreateAttr_t *creat) { int rc = 0; int error; if (rftd->remotehost) { SendCommand(rftd, "%s %s %d %d %d", SAMRFT_CMD_MKDIR, dirname, creat->mode, creat->uid, creat->gid); if (GetReply(rftd) >= 0) { rc = GetMkdirReply(rftd, &error); if (rc < 0) { SetErrno = error; } } } else { if (mkdir(dirname, (creat->mode & S_IAMB)) == 0) { /* * If creating a directory on an NFS mount point, * daemon does not have permission to change the * ownership. Ignore chown errors. */ (void) chown(dirname, creat->uid, creat->gid); } else { rc = -1; } } return (rc); }
/* * Get information for file system on remote host. Set offline flag * to include the size of all SAM-FS offline files in the capacity. */ int SamrftStatvfs( SamrftImpl_t *rftd, char *path, boolean_t offlineFiles, struct statvfs64 *buf) { int error; int rc = -1; if (rftd->remotehost) { SendCommand(rftd, "%s %s %d", SAMRFT_CMD_STATVFS, path, offlineFiles); if (GetReply(rftd) >= 0) { rc = GetStatvfsReply(rftd, buf, &error); } } else { fsize_t offlineFileSize; rc = statvfs64(path, buf); if (rc == 0 && (strcmp(buf->f_basetype, "samfs") == 0) && offlineFiles == B_TRUE) { offlineFileSize = DiskVolsOfflineFiles(path); /* * Adjust capacity to include size of offline files. */ buf->f_blocks += offlineFileSize / buf->f_frsize; } } return (rc); }
/* * Get information for file on remote host. */ int SamrftStat( SamrftImpl_t *rftd, char *filename, SamrftStatInfo_t *buf) { int error; int rc = -1; if (rftd->remotehost) { SendCommand(rftd, "%s %s", SAMRFT_CMD_STAT, filename); if (GetReply(rftd) >= 0) { rc = GetStatReply(rftd, buf, &error); } } else { struct stat64 sb; rc = stat64(filename, &sb); if (rc == 0) { buf->mode = sb.st_mode; buf->uid = sb.st_uid; buf->gid = sb.st_gid; buf->size = sb.st_size; } } return (rc); }
/* * Move read/write file pointer on remote host. */ int SamrftSeek( SamrftImpl_t *rftd, off64_t setpos, int whence, off64_t *offset) { int rc = -1; int error; if (rftd->remotehost) { SendCommand(rftd, "%s %lld %d", SAMRFT_CMD_SEEK, setpos, whence); if (GetReply(rftd) >= 0) { rc = GetSeekReply(rftd, offset, &error); if (rc < 0) { SetErrno = error; } } } else { *offset = lseek64(rftd->fd, setpos, whence); if (*offset != -1) { rc = 0; } } return (rc); }
/* * Load removable-media volume on remote host. Parameter attr * is a pointer to a sam_rminfo structure describing information * about the removable-media to be loaded. */ int SamrftLoadVol( SamrftImpl_t *rftd, struct sam_rminfo *attr, int oflag) { int error; int rc = -1; Trace(TR_RFT, "Samrft [%d] load volume %s.%s %d", traceRftd(rftd), attr->media, attr->section[0].vsn, oflag); /* * If first open following connect, initialize data ports. */ if (rftd->crew == NULL) { if (initDataPorts(rftd) < 0) { return (rc); } } SendCommand(rftd, "%s %d %s %s %s %s %s %d", SAMRFT_CMD_LOADVOL, attr->flags, attr->file_id, attr->owner_id, attr->group_id, attr->media, attr->section[0].vsn, oflag); if (GetReply(rftd) >= 0) { rc = GetLoadVolReply(rftd, &error); } return (rc); }
/* * Close directory on remote host. */ void SamrftClosedir( SamrftImpl_t *rftd, int dirp) { SendCommand(rftd, "%s %d", SAMRFT_CMD_CLOSEDIR, dirp); (void) GetReply(rftd); }
void Handle(const CString& sNick) { if (m_Messaged.HasItem(sNick)) return; if (m_pUser->IsUserAttached()) return; m_Messaged.AddItem(sNick); PutIRC("PRIVMSG " + sNick + " :" + GetReply()); }
void TCPClientThread::PushReply() { if (!data_waiting) return ; // Nothing to push GetReply(); // Wait for request to finish. reply = new ServerToClientReply(reply); // Create new and push old. data_waiting = false; _RPT0(0, "TCPClient: Pushed reply.\n"); }
/* * Write to file on remote host. */ size_t SamrftWrite( SamrftImpl_t *rftd, void *buf, size_t nbytes) { int rc; int error; size_t bytes_written; #if 0 Trace(TR_RFT, "Samrft [%d] write %d", fileno(rftd->cin), nbytes); #endif if (rftd->remotehost) { /* * Send command. Used as information by client to * start reading data sockets. A reply is not expected until * the data transfer has completed. */ SendCommand(rftd, "%s %d", SAMRFT_CMD_SEND, nbytes); rc = SendData(rftd, buf, nbytes); if (GetReply(rftd) >= 0) { rc = GetSendReply(rftd, &error); if (rc < 0) { if (error == 0) { /* Short write failure. */ SetErrno = ENOSPC; } else { SetErrno = error; } bytes_written = (long)-1; } else { bytes_written = nbytes; } } } else { /* * Write to local file. */ bytes_written = write(rftd->fd, buf, nbytes); if (bytes_written != nbytes && errno == 0) { /* Short write failure. */ SetErrno = ENOSPC; } } #if 0 Trace(TR_RFT, "Samrft [%d] write complete %d", traceRftd(rftd), bytes_written); #endif return (bytes_written); }
// // Calls each of the Get functions. // void CAccessDialog::GetAll(Access_Spec * spec) { spec->size = GetSize(); spec->of_size = GetAccess(); spec->reads = GetReads(); spec->random = GetRandom(); spec->delay = GetDelay(); spec->burst = GetBurst(); spec->align = GetAlign(); spec->reply = GetReply(); }
/* * Remove directory on remote host. */ int SamrftRmdir( SamrftImpl_t *rftd, char *dirname) { int rc; SendCommand(rftd, "%s %s", SAMRFT_CMD_RMDIR, dirname); rc = GetReply(rftd); return (rc); }
// // User selected "No Reply" radio button - disable reply size edit boxes, other stuff // void CAccessDialog::OnRNoReply() { // Get the current reply size. DWORD old_reply = GetReply(); // Disable the reply controls. EnableMKBControls(&reply_controls, FALSE); // Set the reply size in the access spec to "none". SetReply(0); // Set the (disabled) reply size controls to the last value shown. SetMKBSpinners(&reply_controls, old_reply); }
bool ReadModule::ReceiveAck(zmq::socket_t *s, bool & state, bool blocking) { int reply_size = 0; char *reply = GetReply(s, state, blocking, reply_size); if (reply == NULL) return false; std::string req = std::string(reply); delete [] reply; if (req.find("ACK") != std::string::npos) { if (debug) std::cout << "Got ACK, thanks!" << std::endl; return true; } std::cerr << "Error: got \"" << req << "\", no ACK, state compromised" << std::endl; return false; }
/* * Check if mount point on remote host is available. */ int SamrftIsMounted( SamrftImpl_t *rftd, char *mount_point) { int mounted = 0; SendCommand(rftd, "%s %s", SAMRFT_CMD_ISMOUNTED, mount_point); if (GetReply(rftd) >= 0) { mounted = GetIsMountedReply(rftd); } return (mounted); }
virtual void OnModCommand(const CString& sCommand) { const CString& sCmd = sCommand.Token(0); if (sCmd.Equals("SHOW")) { PutModule("Current reply is: " + GetNV("Reply") + " (" + GetReply() + ")"); } else if (sCmd.Equals("SET")) { SetReply(sCommand.Token(1, true)); PutModule("New reply set"); } else { PutModule("Available commands are:"); PutModule("Show - Displays the current query reply"); PutModule("Set <reply> - Sets a new reply"); } }
void Handle(const CString& sNick) { CIRCSock *pIRCSock = GetUser()->GetIRCSock(); if (!pIRCSock) // WTF? return; if (sNick == pIRCSock->GetNick()) return; if (m_Messaged.HasItem(sNick)) return; if (m_pUser->IsUserAttached()) return; m_Messaged.AddItem(sNick); PutIRC("PRIVMSG " + sNick + " :" + GetReply()); }
/* * Open a disk file on remote host. */ int SamrftOpen( SamrftImpl_t *rftd, char *filename, int oflag, SamrftCreateAttr_t *creat) { int rc; int error; Trace(TR_RFT, "Samrft [%d] open file %s %d %x", traceRftd(rftd), filename, oflag, creat); /* * If first open following connect, initialize data ports. */ if (rftd->crew == NULL) { if (initDataPorts(rftd) < 0) { return (-1); } } if (rftd->remotehost) { if (creat) { SendCommand(rftd, "%s %s %d %d %d %d %d", SAMRFT_CMD_OPEN, filename, oflag, TRUE, creat->mode, creat->uid, creat->gid); } else { SendCommand(rftd, "%s %s %d %d", SAMRFT_CMD_OPEN, filename, oflag, FALSE); } if (GetReply(rftd) >= 0) { rc = GetOpenReply(rftd, &error); if (rc < 0) { SetErrno = error; } } } else { /* * Open file on local machine. */ rc = openLocalFile(rftd, filename, oflag, creat); } return (rc); }
/* * Unlink file or directory on local or remote host. */ int SamrftUnlink( SamrftImpl_t *rftd, char *name ) { int rc; if (rftd->remotehost) { SendCommand(rftd, "%s %s", SAMRFT_CMD_UNLINK, name); rc = GetReply(rftd); } else { rc = unlink(name); } return (rc); }
/* * Position removable-media on remote host. */ int SamrftSeekVol( SamrftImpl_t *rftd, int block) { int error; int rc = -1; Trace(TR_RFT, "Samrft [%d] seek vol %d", traceRftd(rftd), block); SendCommand(rftd, "%s %d", SAMRFT_CMD_SEEKVOL, block); if (GetReply(rftd) >= 0) { rc = GetSeekVolReply(rftd, &error); } return (rc); }
/* * Unload removable-media volume on remote host. */ int SamrftUnloadVol( SamrftImpl_t *rftd, struct sam_ioctl_rmunload *unload) { int error; int rc = -1; Trace(TR_RFT, "Samrft [%d] unload volume %d", traceRftd(rftd), unload->flags); SendCommand(rftd, "%s %d", SAMRFT_CMD_UNLOADVOL, unload->flags); if (GetReply(rftd) >= 0) { rc = GetUnloadVolReply(rftd, &unload->position, &error); } return (rc); }
/* * Get removable-media information on remote host. */ int SamrftGetVolInfo( SamrftImpl_t *rftd, struct sam_rminfo *getrm, int *eq) { int error; int rc = -1; Trace(TR_RFT, "Samrft [%d] get volinfo", traceRftd(rftd)); SendCommand(rftd, "%s", SAMRFT_CMD_GETVOLINFO); if (GetReply(rftd) >= 0) { rc = GetVolInfoReply(rftd, getrm, eq, &error); } return (rc); }
/* * Accumulate space used for selected path. Space used is calculated * by walking the entire path and stat each file. This method will * accumulate space used for online and offline files. */ int SamrftSpaceUsed( SamrftImpl_t *rftd, char *path, fsize_t *used) { int error; int rc = -1; if (rftd->remotehost) { SendCommand(rftd, "%s %s", SAMRFT_CMD_SPACEUSED, path); if (GetReply(rftd) >= 0) { rc = GetSpaceUsedReply(rftd, used, &error); } } else { *used = DiskVolsAccumSpaceUsed(path); } return (rc); }
/* * Read from file on remote host. */ size_t SamrftRead( SamrftImpl_t *rftd, void *buf, size_t nbytes) { int rc; int error; size_t bytes_read; #if 0 Trace(TR_RFT, "Samrft [%d] read %d", traceRftd(rftd), nbytes); #endif if (rftd->remotehost) { SendCommand(rftd, "%s %d", SAMRFT_CMD_RECV, nbytes); rc = ReceiveData(rftd, buf, nbytes); if (GetReply(rftd) >= 0) { rc = GetRecvReply(rftd, &error); if (rc < 0) { SetErrno = error; bytes_read = (long)-1; } else { bytes_read = nbytes; } } } else { /* * Read data from local file. */ bytes_read = read(rftd->fd, buf, nbytes); } #if 0 Trace(TR_RFT, "Samrft [%d] read complete %d", traceRftd(rftd), bytes_read); #endif return (bytes_read); }
/* * Open directory on remote host. */ int SamrftOpendir( SamrftImpl_t *rftd, char *dirname, int *dirp) { int rc = -1; int error; SendCommand(rftd, "%s %s", SAMRFT_CMD_OPENDIR, dirname); if (GetReply(rftd) >= 0) { rc = GetOpendirReply(rftd, dirp, &error); if (rc < 0) { SetErrno = error; } } return (rc); }
/* * Read directory on remote host. */ int SamrftReaddir( SamrftImpl_t *rftd, int dirp, SamrftReaddirInfo_t *dir_info) { int rc = -1; int error; SendCommand(rftd, "%s %d", SAMRFT_CMD_READDIR, dirp); if (GetReply(rftd) >= 0) { rc = GetReaddirReply(rftd, dir_info, &error); if (rc < 0) { SetErrno = error; } } return (rc); }
int* ReadModule::readInput(bool blocking) { pthread_mutex_lock(&cmdMutex); int reply_size = -1; char *reply = GetReply(portInputIn.sock, portInputIn.ready, blocking, reply_size); if (!portInputIn.ready) { delete [] reply; pthread_mutex_unlock(&cmdMutex); return NULL; } if (reply == NULL) { pthread_mutex_unlock(&cmdMutex); return NULL; } SendAck(portInputIn.sock, portInputIn.ready); pthread_mutex_unlock(&cmdMutex); if (reply_size < 1) std::cerr << "Error: Reply is not large enough to store a value!" << std::endl; std::stringstream ss; ss.clear(); ss.str(""); ss << std::string(reply); ss >> portInputValue; delete [] reply; return &portInputValue; }