/*>int QueueJob(char *queueDir, char *lockFullFile, char **progArgs, int nProgArgs, int maxWait, int *nJobsWaiting) ----------------------------------------------------------------- *//** \param[in] *queueDir The queue directory \param[in] *lockFullFile Full path and name of lock file \param[in] **progArgs The program name and arguments \param[in] nProgArgs The size of the arguments array \param[in] maxWait Max time to wait to create a job \param[out] *nJobsWaiting Number of jobs in the queue \return Job ID for this job Adds a job to the queue and returns the number of jobs now in the queue. - 16.10.15 Original By: ACRM - 19.10.15 Now returns jobID and outputs number of jobs */ int QueueJob(char *queueDir, char *lockFullFile, char **progArgs, int nProgArgs, int maxWait, int *nJobsWaiting) { int jobID = 1, /* Default JOBID */ waitCount = 0, fh, nJobs; *nJobsWaiting = 0; /* Wait while the lock file is present */ while(FileExists(lockFullFile)) { if(++waitCount > maxWait) { Message(PROGNAME, MSG_FATAL, "Cannot submit job - lockfile is not clearing"); } sleep(1); } /* Create lock file */ if((fh = FlockFile(lockFullFile)) == (-1)) { Message(PROGNAME, MSG_FATAL, "Cannot create lock file"); } /* Find the latest job and number of jobs queued */ nJobs = FindJobs(queueDir, JOB_NEWEST, &jobID); if(nJobs) jobID++; /* Write the job file */ WriteJobFile(queueDir, jobID, progArgs, nProgArgs); /* Remove the lock file */ FunlockFile(fh, lockFullFile); *nJobsWaiting = nJobs+1; return(jobID); }
/* * Execute command. */ void DoCommand( Client_t *cli) { int rc; char *cmd_name; char *lasts; char *msg; rc = 0; SetErrno = 0; msg = cli->cmdbuf; /* * Extract command name. */ /* LINTED improper pointer/integer combination */ cmd_name = strtok_r(msg, " ", &lasts); if (strcmp(cmd_name, SAMRFT_CMD_CONNECT) == 0) { SendReply(cli, "%s %d %d", SAMRFT_CMD_CONNECT, 0, 0); } else if (strcmp(cmd_name, SAMRFT_CMD_CONFIG) == 0) { char *hostname; int blksize; int tcpwindowsize; hostname = getString(&lasts); blksize = GetCfgBlksize(); tcpwindowsize = GetCfgTcpWindowsize(); SamStrdup(cli->hostname, hostname); rc = CreateCrew(cli, 1, blksize); SendReply(cli, "%s %d %d %d %d", SAMRFT_CMD_CONFIG, rc, 1, blksize, tcpwindowsize); } else if (strcmp(cmd_name, SAMRFT_CMD_OPEN) == 0) { char *filename; int oflag; SamrftCreateAttr_t creat; filename = getString(&lasts); oflag = getInteger(&lasts); if (getInteger(&lasts)) { (void) memset((char *)&creat, 0, sizeof (SamrftCreateAttr_t)); creat.mode = getInteger(&lasts); creat.uid = getInteger(&lasts); creat.gid = getInteger(&lasts); rc = OpenFile(cli, filename, oflag, &creat); } else { rc = OpenFile(cli, filename, oflag, NULL); } SendReply(cli, "%s %d %d", SAMRFT_CMD_OPEN, rc, errno); } else if (strcmp(cmd_name, SAMRFT_CMD_DPORT) == 0) { struct sockaddr_in data; int seqnum; char *addr = (char *)&data.sin_addr; char *port = (char *)&data.sin_port; (void) memset((char *)&data, 0, sizeof (struct sockaddr_in)); data.sin_family = AF_INET; seqnum = getInteger(&lasts); /* * Addr. */ addr[0] = getInteger(&lasts); addr[1] = getInteger(&lasts); addr[2] = getInteger(&lasts); addr[3] = getInteger(&lasts); /* * Port. */ port[0] = getInteger(&lasts); port[1] = getInteger(&lasts); rc = InitDataConnection(cli, "r", seqnum, data.sin_family, (struct sockaddr *)&data); SendReply(cli, "%s %d %d", SAMRFT_CMD_DPORT, rc, errno); } else if (strcmp(cmd_name, SAMRFT_CMD_DPORT6) == 0) { struct sockaddr_in6 data; struct sockaddr_in *data4 = (struct sockaddr_in *)&data; int i; int seqnum; char *addr; char *port; (void) memset((char *)&data, 0, sizeof (struct sockaddr_in6)); seqnum = getInteger(&lasts); /* * Address family. */ data.sin6_family = getInteger(&lasts); if (data.sin6_family == AF_INET6) { addr = (char *)&data.sin6_addr; port = (char *)&data.sin6_port; } else { addr = (char *)&data4->sin_addr; port = (char *)&data4->sin_port; } /* * Addr. */ for (i = 0; i < 16; i++) { addr[i] = getInteger(&lasts); } /* * Port. */ port[0] = getInteger(&lasts); port[1] = getInteger(&lasts); rc = InitDataConnection(cli, "r", seqnum, data.sin6_family, (struct sockaddr *)&data); SendReply(cli, "%s %d %d", SAMRFT_CMD_DPORT6, rc, errno); } else if (strcmp(cmd_name, SAMRFT_CMD_STOR) == 0) { fsize_t nbytes; nbytes = getLongLong(&lasts); rc = ReceiveData(cli, nbytes); } else if (strcmp(cmd_name, SAMRFT_CMD_SEND) == 0) { size_t nbytes; nbytes = getInteger(&lasts); rc = ReceiveData(cli, nbytes); SendReply(cli, "%s %d %d", SAMRFT_CMD_SEND, rc, errno); } else if (strcmp(cmd_name, SAMRFT_CMD_RECV) == 0) { size_t nbytes; nbytes = getInteger(&lasts); /* * Process receive command from client. Send data from local * file over data sockets to the client process. */ rc = SendData(cli, nbytes); SendReply(cli, "%s %d %d", SAMRFT_CMD_RECV, rc, errno); } else if (strcmp(cmd_name, SAMRFT_CMD_SEEK) == 0) { off64_t setpos; int whence; off64_t offset; setpos = getLongLong(&lasts); whence = getInteger(&lasts); rc = SeekFile(cli, setpos, whence, &offset); SendReply(cli, "%s %d %d %lld", SAMRFT_CMD_SEEK, rc, errno, offset); } else if (strcmp(cmd_name, SAMRFT_CMD_FLOCK) == 0) { int type; type = getInteger(&lasts); rc = FlockFile(cli, type); SendReply(cli, "%s %d %d", SAMRFT_CMD_FLOCK, rc, errno); } else if (strcmp(cmd_name, SAMRFT_CMD_ARCHIVEOP) == 0) { char *path; char *ops; path = getString(&lasts); ops = getString(&lasts); rc = sam_archive(path, ops); SendReply(cli, "%s %d %d", SAMRFT_CMD_ARCHIVEOP, rc, errno); } else if (strcmp(cmd_name, SAMRFT_CMD_CLOSE) == 0) { rc = CloseFile(cli); SendReply(cli, "%s %d %d", SAMRFT_CMD_CLOSE, rc, errno); } else if (strcmp(cmd_name, SAMRFT_CMD_UNLINK) == 0) { char *name; name = getString(&lasts); rc = UnlinkFile(cli, name); SendReply(cli, "%s %d %d", SAMRFT_CMD_UNLINK, rc, errno); } else if (strcmp(cmd_name, SAMRFT_CMD_DISCONN) == 0) { Trace(TR_DEBUG, "RFT disconnect, no reply: '%s'", cli->cmdbuf); CleanupCrew(cli); cli->disconnect = 1; /* * No reply. */ } else if (strcmp(cmd_name, SAMRFT_CMD_ISMOUNTED) == 0) { int mounted; char *mount_point; mount_point = getString(&lasts); mounted = IsMounted(cli, mount_point); SendReply(cli, "%s %d", SAMRFT_CMD_ISMOUNTED, mounted); } else if (strcmp(cmd_name, SAMRFT_CMD_STAT) == 0) { struct stat64 buf; char *filename; filename = getString(&lasts); (void) memset(&buf, 0, sizeof (buf)); rc = stat64(filename, &buf); SendReply(cli, "%s %d %d %d %d %d %lld", SAMRFT_CMD_STAT, rc, errno, buf.st_mode, buf.st_uid, buf.st_gid, buf.st_size); } else if (strcmp(cmd_name, SAMRFT_CMD_STATVFS) == 0) { struct statvfs64 buf; char *mount_point; int offlineFiles; fsize_t offlineFileSize; mount_point = getString(&lasts); offlineFiles = getInteger(&lasts); (void) memset(&buf, 0, sizeof (buf)); rc = statvfs64(mount_point, &buf); if (rc == 0 && (strcmp(buf.f_basetype, "samfs") == 0) && offlineFiles == B_TRUE) { offlineFileSize = DiskVolsOfflineFiles(mount_point); /* * Adjust capacity to include size of offline files. */ buf.f_blocks += offlineFileSize / buf.f_frsize; } SendReply(cli, "%s %d %d %lld %lld %ld %s", SAMRFT_CMD_STATVFS, rc, errno, buf.f_bfree, buf.f_blocks, buf.f_frsize, buf.f_basetype); } else if (strcmp(cmd_name, SAMRFT_CMD_SPACEUSED) == 0) { char *path; fsize_t spaceUsed; path = getString(&lasts); spaceUsed = DiskVolsAccumSpaceUsed(path); SendReply(cli, "%s %d %d %lld", SAMRFT_CMD_SPACEUSED, rc, errno, spaceUsed); } else if (strcmp(cmd_name, SAMRFT_CMD_MKDIR) == 0) { char *dirname; int mode, uid, gid; dirname = getString(&lasts); mode = getInteger(&lasts); uid = getInteger(&lasts); gid = getInteger(&lasts); rc = MkDir(cli, dirname, mode, uid, gid); SendReply(cli, "%s %d %d", SAMRFT_CMD_MKDIR, rc, errno); } else if (strcmp(cmd_name, SAMRFT_CMD_OPENDIR) == 0) { char *dirname; int dirp; dirname = getString(&lasts); rc = OpenDir(cli, dirname, &dirp); SendReply(cli, "%s %d %d %d", SAMRFT_CMD_OPENDIR, rc, errno, dirp); } else if (strcmp(cmd_name, SAMRFT_CMD_READDIR) == 0) { int dirp; SamrftReaddirInfo_t dir_info; dirp = getInteger(&lasts); rc = ReadDir(cli, dirp, &dir_info); if (rc == 0) { SendReply(cli, "%s %d %d %s %d", SAMRFT_CMD_READDIR, rc, errno, dir_info.name, dir_info.isdir); } else { SendReply(cli, "%s %d %d", SAMRFT_CMD_READDIR, rc, errno); } } else if (strcmp(cmd_name, SAMRFT_CMD_CLOSEDIR) == 0) { int dirp; dirp = getInteger(&lasts); CloseDir(cli, dirp); SendReply(cli, "%s %d %d", SAMRFT_CMD_CLOSEDIR, 0, 0); } else if (strcmp(cmd_name, SAMRFT_CMD_RMDIR) == 0) { char *dirname; dirname = getString(&lasts); rc = RmDir(cli, dirname); SendReply(cli, "%s %d %d", SAMRFT_CMD_CLOSEDIR, rc, errno); } else if (strcmp(cmd_name, SAMRFT_CMD_LOADVOL) == 0) { struct sam_rminfo rb; int oflag; /* * Create sam_rminfo structure used to create * a removable-media file. */ (void) memset(&rb, 0, sizeof (rb)); rb.flags = getInteger(&lasts); (void) strncpy(rb.file_id, getString(&lasts), sizeof (rb.file_id)); (void) strncpy(rb.owner_id, getString(&lasts), sizeof (rb.owner_id)); (void) strncpy(rb.group_id, getString(&lasts), sizeof (rb.group_id)); rb.n_vsns = 1; (void) strncpy(rb.media, getString(&lasts), sizeof (rb.media)); (void) strncpy(rb.section[0].vsn, getString(&lasts), sizeof (rb.section[0].vsn)); oflag = getInteger(&lasts); rc = LoadVol(cli, &rb, oflag); SendReply(cli, "%s %d %d", SAMRFT_CMD_LOADVOL, rc, errno); } else if (strcmp(cmd_name, SAMRFT_CMD_GETVOLINFO) == 0) { struct sam_rminfo getrm; int eq; rc = GetVolInfo(cli, &getrm, &eq); SendReply(cli, "%s %d %d %d %lld %d", SAMRFT_CMD_GETVOLINFO, rc, errno, getrm.block_size, getrm.position, eq); } else if (strcmp(cmd_name, SAMRFT_CMD_SEEKVOL) == 0) { int block; block = getInteger(&lasts); rc = SeekVol(cli, block); SendReply(cli, "%s %d %d", SAMRFT_CMD_SEEKVOL, rc, errno); } else if (strcmp(cmd_name, SAMRFT_CMD_UNLOADVOL) == 0) { struct sam_ioctl_rmunload unload; /* * Create sam_rmunload structure used to unload * a removable-media file. */ (void) memset(&unload, 0, sizeof (unload)); unload.flags = getInteger(&lasts); rc = UnloadVol(cli, &unload); SendReply(cli, "%s %d %d %lld", SAMRFT_CMD_UNLOADVOL, rc, errno, unload.position); } else { Trace(TR_ERR, "Unknown RFT command: %s", cmd_name); } }