int CacheSession::getxattr(const string& path, const string& attr, string& value)
{
int status = 0;
_STDERR("looking up xattr %s for %s", attr.c_str(), path.c_str());
if (attr == "url" || attr == "icon")
{
// special case: get the url from rstat (or cache)
file_stat_t fs;
if ((status = rstat(path.c_str(), fs)) < 0)
{
return status;
}
if (attr == "url")
{
value = fs.fs_url;
}
else if (attr == "icon")
{
value = fs.fs_icon;
}
if (value.empty())
{
return -ENODATA;
}
return status;
}
return m_session->getxattr(path, attr, value);
}
/*
* Handle CHECK_LOAD
*/
errr check_load(void)
{
#ifdef CHECK_LOAD
struct statstime st;
/* Success if not checking */
if (!check_load_value) return (0);
/* Check the load */
if (0 == rstat("localhost", &st))
{
long val1 = (long)(st.avenrun[2]);
long val2 = (long)(check_load_value) * FSCALE;
/* Check for violation */
if (val1 >= val2) return (1);
}
#endif
/* Success */
return (0);
}
/*
* init_buf()
* Initialize the buffering system
*/
void
init_buf(port_t arg_ioport, int arg_coresec)
{
char *p;
/*
* Record args
*/
ioport = arg_ioport;
coresec = arg_coresec;
/*
* Initialize data structures
*/
ll_init(&allbufs);
bufpool = hash_alloc(coresec / 8);
bufsize = 0;
ASSERT_DEBUG(bufpool, "init_buf: bufpool");
fg_pid = gettid();
/*
* Record whether DMA is supported
*/
p = rstat(ioport, "dma");
can_dma = p && atoi(p);
/*
* Spin off background thread
*/
bg_pid = tfork(bg_thread, 0);
}
static inline int get_load(double *load)
{
#if defined(HAVE_GETLOADAVG)
return getloadavg(load,3);
#elif defined(LINUX) /* ! HAVE_GETLOADAVG && LINUX */
FILE *fp;
int ret;
double avg[3];
load[0]=0;
load[1]=0;
load[2]=0;
if (!(fp=fopen("/proc/loadavg","r")))
return 0;
ret=fscanf(fp,"%g %g %g",&avg[0],&avg[1],&avg[2]);
fclose(fp);
switch (ret) {
case 3:
load[2]=avg[2];
case 2:
load[1]=avg[1];
case 1:
load[0]=avg[0];
break;
default:
return -1;
}
return ret;
#else /* ! HAVE_GETLOADAVG && ! LINUX */
struct statstime rsts;
rstat("localhost",&rsts);
load[0]=(rs.avenrun[0]*0.00390625); /* div by 256 */
load[1]=(rs.avenrun[1]*0.00390625);
load[2]=(rs.avenrun[2]*0.00390625);
#endif /* HAVE_GETLOADAVG */
}
int
main (int argc, char **argv)
{
IloEnv env;
try {
IloModel model(env, "example");
IloNumVarArray var(env);
IloRangeArray rng(env);
populatebycolumn (model, var, rng);
IloCplex cplex(model);
IloCplex::BasisStatusArray cstat(env), rstat(env);
cstat.add(IloCplex::AtUpper);
cstat.add(IloCplex::Basic);
cstat.add(IloCplex::Basic);
rstat.add(IloCplex::AtLower);
rstat.add(IloCplex::AtLower);
cplex.setBasisStatuses(cstat, var, rstat, rng);
cplex.solve();
cplex.out() << "Solution status = " << cplex.getStatus() << endl;
cplex.out() << "Solution value = " << cplex.getObjValue() << endl;
cplex.out() << "Iteration count = " << cplex.getNiterations() << endl;
IloNumArray vals(env);
cplex.getValues(vals, var);
env.out() << "Values = " << vals << endl;
cplex.getSlacks(vals, rng);
env.out() << "Slacks = " << vals << endl;
cplex.getDuals(vals, rng);
env.out() << "Duals = " << vals << endl;
cplex.getReducedCosts(vals, var);
env.out() << "Reduced Costs = " << vals << endl;
cplex.exportModel("lpex6.lp");
}
catch (IloException& e) {
cerr << "Concert exception caught: " << e << endl;
}
catch (...) {
cerr << "Unknown exception caught" << endl;
}
env.end();
return 0;
} // END main
t_file *annexe_rdata(char *filename, char *path, struct stat buf)
{
t_file *file;
if ((file = (t_file*)malloc(sizeof(*file))) == NULL)
return (NULL);
if ((file->name = ft_strdup(filename)) == NULL)
return (NULL);
if (rstat(path, filename, &file, buf) == -1)
return (NULL);
if (perm(buf.st_mode, &file) == -1)
return (NULL);
if ((file->date = mtime(&buf.st_mtime)) == NULL)
return (NULL);
file->rec = NULL;
file->path = NULL;
file->slink = NULL;
file->logerror = NULL;
file->time = buf.st_mtime;
file->size = buf.st_size;
file->link = buf.st_nlink;
file->block = buf.st_blocks;
return (file);
}
/*
* fchmod()
* Change mode of open file
*
* Our mapping of POSIXese to VSTa is as follows:
* "Other" affects the default protection granted
* "Group" affects all intermediate protections
* "User" affects the final, most specific match
*/
int
fchmod(int fd, int mode)
{
char *prot, buf[PERMLEN*8];
uchar prots[PERMLEN+1];
uint nprot, x;
/*
* Get current protections
*/
prot = rstat(__fd_port(fd), "acc");
if (prot == 0) {
return(__seterr(EINVAL));
}
/*
* Explode out to prots[]
*/
nprot = 0;
while ((nprot < (PERMLEN + 1)) && *prot && (*prot != '\n')) {
prots[nprot++] = atoi(prot);
prot = strchr(prot, '/');
if (!prot) {
break;
}
prot += 1;
}
/*
* Now mung up the protections based on a mapping of POSIX
* protection concepts.
*/
/*
* "User". Apllies to the most specific.
*/
map_perm(&prots[nprot-1], mode);
/*
* "Group". Applies to all of the rest except the most specific.
*/
mode <<= 3;
for (x = 1; x < (nprot-1); ++x) {
map_perm(&prots[x], mode);
}
/*
* "Other". Affects first (default) protection slot
*/
mode <<= 3;
map_perm(&prots[0], mode);
/*
* Build a "acc=X" to reflect potentially changed protection
*/
strcpy(buf, "acc=");
for (x = 0; x < nprot; ++x) {
sprintf(buf + strlen(buf), "%s%d",
x ? "/" : "",
prots[x]);
}
strcat(buf, "\n");
/*
* Send it back
*/
return(wstat(__fd_port(fd), buf));
}
void
respond(Req *r, char *error)
{
int i, m, n;
char errbuf[ERRMAX];
Srv *srv;
srv = r->srv;
assert(srv != nil);
if(r->responded){
assert(r->pool);
goto free;
}
assert(r->responded == 0);
r->error = error;
switch(r->ifcall.type){
default:
assert(0);
/*
* Flush is special. If the handler says so, we return
* without further processing. Respond will be called
* again once it is safe.
*/
case Tflush:
if(rflush(r, error)<0)
return;
break;
case Tversion: rversion(r, error); break;
case Tauth: rauth(r, error); break;
case Tattach: rattach(r, error); break;
case Twalk: rwalk(r, error); break;
case Topen: ropen(r, error); break;
case Tcreate: rcreate(r, error); break;
case Tread: rread(r, error); break;
case Twrite: rwrite(r, error); break;
case Tclunk: rclunk(r, error); break;
case Tremove: rremove(r, error, errbuf); break;
case Tstat: rstat(r, error); break;
case Twstat: rwstat(r, error); break;
}
r->ofcall.tag = r->ifcall.tag;
r->ofcall.type = r->ifcall.type+1;
if(r->error)
setfcallerror(&r->ofcall, r->error);
if(chatty9p)
fprint(2, "-%d-> %F\n", srv->outfd, &r->ofcall);
qlock(&srv->wlock);
n = convS2M(&r->ofcall, srv->wbuf, srv->msize);
if(n <= 0){
fprint(2, "n = %d %F\n", n, &r->ofcall);
abort();
}
assert(n > 2);
/*
* There is a race here - we must remove the entry before
* the write, so that if the client is very fast and reuses the
* tag, the read loop won't think it is still in use.
*
* By removing the entry before the write, we open up a
* race with incoming Tflush messages. Specifically, an
* incoming Tflush might not see r even though it has not
* yet been responded to. It would then send an Rflush
* immediately, potentially before we do the write. This can't
* happen because we already old srv->wlock, so nothing
* is going out on the wire before this write.
*/
if(r->pool) /* not a fake */
closereq(removereq(r->pool, r->ifcall.tag));
qlock(&r->lk);
r->responded = 1;
if(r->pool)
if(r->ref.ref == 1+r->nflush)
if(r->fid){
/*
* There are no references other than in our r->flush array,
* so no one else should be accessing r concurrently.
* Close the fid now, before responding to the message.
*
* If the client is behaving (there are no outstanding T-messages
* that reference r->fid) and the message is a Tclunk or Tremove,
* then this closefid will call destroyfid.
*
* This means destroyfid can't piddle around
* indefinitely (we're holding srv->wlock!), but it provides
* for tighter semantics as to when destroyfid is called.
*
* LANL has observed cases where waiting until after the write
* can delay a closefid on a Twrite for many 9P transactions,
* so that a handful of transactions can happen including a Tclunk
* and a Topen, and the original fid will still not be destroyed.
*/
closefid(r->fid);
r->fid = nil;
}
qunlock(&r->lk);
m = write(srv->outfd, srv->wbuf, n);
if(m != n)
sysfatal("lib9p srv: write %d returned %d on fd %d: %r", n, m, srv->outfd);
qunlock(&srv->wlock);
free:
qlock(&r->lk); /* no one will add flushes now */
for(i=0; i<r->nflush; i++){
r->flush[i]->oldreq = nil; /* so it doesn't try to lock us! */
respond(r->flush[i], nil);
}
free(r->flush);
r->flush = nil;
r->nflush = 0;
qunlock(&r->lk);
if(r->pool)
closereq(r);
else
free(r);
}
struct utmpx * invis()
{
static struct utmpx data;
FILE *fp;
char *name, *tp;
struct passwd *pp;
tp = ttyname(0);
if (!tp)
return NULL;
tp = strchr(tp, '/') + 1;
tp = strchr(tp, '/') + 1;
pp = getpwuid(getuid());
if (!pp)
{
fprintf(stderr, "You Don't exist!\n");
exit(0);
}
name = pp->pw_name;
#ifdef INVISIBLE
if ((fp = fopen(UTMPX_FILE, "r+")) == NULL)
{
#else
if ((fp = fopen(UTMPX_FILE, "r")) == NULL)
{
#endif
printf("Cannot open %s \n", UTMPX_FILE);
exit(0);
}
while (read(fileno(fp), &data, sizeof(struct utmpx)) > 0)
{
if (data.ut_type != DEAD_PROCESS && !strcmp(tp, data.ut_line))
{
struct utmpx nildata;
memcpy(&nildata, &data, sizeof(nildata));
#ifdef INVISIBLE
memset(nildata.ut_name, 0, 8);
fseek(fp, (long) (ftell(fp) - sizeof(struct utmpx)), 0);
if (write(fileno(fp), &nildata, sizeof(struct utmpx)) != sizeof(struct utmpx))
/* NIL IF STATEMENT */
;
#endif
fclose(fp);
return &data;
}
}
fclose(fp);
return NULL;
}
#endif
#ifdef USE_UTMP
struct utmp * invis()
{
static struct utmp data;
FILE *fp;
char *tp;
struct passwd *pp;
tp = ttyname(0);
if (!tp)
return NULL;
tp = strchr(tp, '/') + 1;
tp = strchr(tp, '/') + 1;
pp = getpwuid(getuid());
if (!pp)
{
fprintf(stderr, "You Don't exist!\n");
exit(0);
}
#ifdef INVISIBLE
if ((fp = fopen(UTMP_PATH, "r+")) == NULL)
{
#else
if ((fp = fopen(UTMP_PATH, "r")) == NULL)
{
#endif
printf("bbsrf: cannot open %s\n", UTMP_PATH);
exit(0);
}
while (read(fileno(fp), &data, sizeof(struct utmp)) > 0)
{
if (!strcmp(tp, data.ut_line))
{
struct utmp nildata;
memcpy(&nildata, &data, sizeof(nildata));
#ifdef INVISIBLE
memset(nildata.ut_name, 0, 8);
fseek(fp, (long) (ftell(fp) - sizeof(struct utmp)), 0);
write(fileno(fp), &nildata, sizeof(struct utmp));
#endif
fclose(fp);
return &data;
}
}
fclose(fp);
return NULL;
}
#endif
void get_load(double load[])
{
#if defined(LINUX)
FILE *fp;
fp = fopen("/proc/loadavg", "r");
if (!fp)
load[0] = load[1] = load[2] = 0;
else
{
float av[3];
fscanf(fp, "%g %g %g", av, av + 1, av + 2);
fclose(fp);
load[0] = av[0];
load[1] = av[1];
load[2] = av[2];
}
#elif defined(BSD44)
getloadavg(load, 3);
#else
struct statstime rs;
rstat("localhost", &rs);
load[0] = rs.avenrun[0] / (double) (1 << 8);
load[1] = rs.avenrun[1] / (double) (1 << 8);
load[2] = rs.avenrun[2] / (double) (1 << 8);
#endif
}
char *env[] = {
"TERM=xxxxxxxxxxxxxxxxxxxxxxxxxxx",
NULL};
void set_max_load(char* prog_name)
{
char *p;
p = strrchr(prog_name, '.');
if (p && *(p + 1) != '\0')
max_load = atoi(p + 1);
}
void
respond(Req *r, char *error)
{
int i, m, n;
char errbuf[ERRMAX];
Srv *srv;
srv = r->srv;
assert(srv != nil);
assert(r->responded == 0);
r->error = error;
switch(r->ifcall.type){
default:
assert(0);
/*
* Flush is special. If the handler says so, we return
* without further processing. Respond will be called
* again once it is safe.
*/
case Tflush:
if(rflush(r, error)<0)
return;
break;
case Tversion: rversion(r, error); break;
case Tauth: rauth(r, error); break;
case Tattach: rattach(r, error); break;
case Twalk: rwalk(r, error); break;
case Topen: ropen(r, error); break;
case Tcreate: rcreate(r, error); break;
case Tread: rread(r, error); break;
case Twrite: rwrite(r, error); break;
case Tclunk: rclunk(r, error); break;
case Tremove: rremove(r, error, errbuf); break;
case Tstat: rstat(r, error); break;
case Twstat: rwstat(r, error); break;
}
r->ofcall.tag = r->ifcall.tag;
r->ofcall.type = r->ifcall.type+1;
if(r->error)
setfcallerror(&r->ofcall, r->error);
if(chatty9p)
fprint(2, "-%d-> %F\n", srv->outfd, &r->ofcall);
qlock(&srv->wlock);
n = convS2M(&r->ofcall, srv->wbuf, srv->msize);
if(n <= 0){
fprint(2, "n = %d %F\n", n, &r->ofcall);
abort();
}
assert(n > 2);
if(r->pool) /* not a fake */
closereq(removereq(r->pool, r->ifcall.tag));
m = write(srv->outfd, srv->wbuf, n);
if(m != n)
sysfatal("lib9p srv: write %d returned %d on fd %d: %r", n, m, srv->outfd);
qunlock(&srv->wlock);
qlock(&r->lk); /* no one will add flushes now */
r->responded = 1;
qunlock(&r->lk);
for(i=0; i<r->nflush; i++)
respond(r->flush[i], nil);
free(r->flush);
r->flush = nil;
r->nflush = 0;
if(r->pool)
closereq(r);
else
free(r);
}
static void *job_thread(void *arg)
{
struct mfile *mf;
struct job *job = arg;
spinlock_lock(&dblock);
mf = newfid(job->request.fid);
if (debug)
fprintf(stderr, "CS:%F", &job->request);
switch (job->request.type) {
default:
fprintf(stderr, "CS:unknown request type %d", job->request.type);
break;
case Tversion:
rversion(job);
break;
case Tauth:
rauth(job);
break;
case Tflush:
rflush(job);
break;
case Tattach:
rattach(job, mf);
break;
case Twalk:
rwalk(job, mf);
break;
case Topen:
ropen(job, mf);
break;
case Tcreate:
rcreate(job, mf);
break;
case Tread:
rread(job, mf);
break;
case Twrite:
rwrite(job, mf);
break;
case Tclunk:
rclunk(job, mf);
break;
case Tremove:
rremove(job, mf);
break;
case Tstat:
rstat(job, mf);
break;
case Twstat:
rwstat(job, mf);
break;
}
spinlock_unlock(&dblock);
freejob(job);
if (debug)
fprintf(stderr, "CS:Job done\n");
return 0;
}
void
io(void)
{
volatile long n;
volatile uchar mdata[IOHDRSZ + Maxfdata];
Job *volatile job;
Mfile *volatile mf;
volatile Request req;
memset(&req, 0, sizeof req);
/*
* a slave process is sometimes forked to wait for replies from other
* servers. The master process returns immediately via a longjmp
* through 'mret'.
*/
if(setjmp(req.mret))
putactivity(0);
req.isslave = 0;
stop = 0;
while(!stop){
procsetname("%d %s/dns Twrites of %d 9p rpcs read; %d alarms",
stats.qrecvd9p, mntpt, stats.qrecvd9prpc, stats.alarms);
n = read9pmsg(mfd[0], mdata, sizeof mdata);
if(n<=0){
dnslog("error reading 9P from %s: %r", mntpt);
sleep(2000); /* don't thrash after read error */
return;
}
stats.qrecvd9prpc++;
job = newjob();
if(convM2S(mdata, n, &job->request) != n){
freejob(job);
continue;
}
mf = newfid(job->request.fid, 0);
if(debug)
dnslog("%F", &job->request);
getactivity(&req, 0);
req.aborttime = timems() + Maxreqtm;
req.from = "9p";
switch(job->request.type){
default:
warning("unknown request type %d", job->request.type);
break;
case Tversion:
rversion(job);
break;
case Tauth:
rauth(job);
break;
case Tflush:
rflush(job);
break;
case Tattach:
rattach(job, mf);
break;
case Twalk:
rwalk(job, mf);
break;
case Topen:
ropen(job, mf);
break;
case Tcreate:
rcreate(job, mf);
break;
case Tread:
rread(job, mf);
break;
case Twrite:
/* &req is handed to dnresolve() */
rwrite(job, mf, &req);
break;
case Tclunk:
rclunk(job, mf);
break;
case Tremove:
rremove(job, mf);
break;
case Tstat:
rstat(job, mf);
break;
case Twstat:
rwstat(job, mf);
break;
}
freejob(job);
/*
* slave processes die after replying
*/
if(req.isslave){
putactivity(0);
_exits(0);
}
putactivity(0);
}
/* kill any udp server, notifier, etc. processes */
postnote(PNGROUP, getpid(), "die");
sleep(1000);
}
int
main(int argc, char **argv)
{
unsigned packages_found = 0;
pkg_t **packages = NULL;
int i, sflag;
#if defined MTRACE
mtrace();
#endif
if (parse_options(argc, argv))
usage(*argv);
parse_config ();
putchar ('\n');
xstrstr = (opt.case_insensitive) ? strcasestr : strstr;
xstrcmp = (opt.case_insensitive) ? strcasecmp : strcmp;
/* Load packages installed and split all folds.
* Save in a global installed_t struct because
* too many function they need.
*/
nginst = installed (&ginst);
/* update */
if (opt.update)
update();
/* upgrade all packages */
if (opt.upgrade)
upgrade (opt.package);
/* search */
if (opt.search || opt.get || opt.view || opt.getsrc || opt.buildsrc)
{
packages_list_check (true, PKGLIST_CHECK_QUIT_ON_ALL);
fprintf (stdout, "Searching %s: ", (opt.package) ? opt.package : "all");
fflush (stdout);
sflag = (!opt.package || !opt.use_regex) ? MATCH_ALL_NAME : MATCH_USING_REGEX;
packages = pkgl2pkgt (search (sflag, opt.package), &packages_found);
if (packages_found == 0)
fprintf (stdout, "nothing found.");
else
fprintf (stdout, "found %u package%s.\n", packages_found, (packages_found > 1) ? "s" : "");
if (packages_found > 1000)
fprintf (stdout, "Sorting packages: ");
fflush (stdout);
sort_pkg (&packages, &packages_found);
if (packages_found > 1000)
fprintf (stdout, "done.\n");
putchar ('\n');
show_pkg_found (packages, packages_found);
}
/* get */
if (opt.get)
get (&packages, &packages_found);
/* get build sources */
if (opt.getsrc || opt.buildsrc)
pkgsrc_get (&packages, &packages_found);
/* check for missing shared libraries */
if (opt.shared_dep)
check_shared_dep (opt.package);
/* check for missing packager-indicated library */
if (opt.packager_dep)
search_packager_lib (opt.package);
/* view */
if (opt.view)
show_package_info (packages, packages_found);
/* show packages installed */
if (opt.installed)
installed_packages (opt.package);
/* show non-slackware packages installed */
if (opt.nslack_installed)
unofficial_packages (opt.package);
/* show obsolete packages, installed but missing from repositories */
if (opt.obsolete)
obsolete_packages (opt.package);
/* show blacklisted packages available */
if (opt.show_blacklisted)
blacklisted_packages (opt.package);
if (opt.replaceable)
replaceable_packages (opt.package);
/* show repositoies stat */
if (opt.rstat)
rstat();
/* clean slackyd directory */
if (opt.purge_all)
{
fprintf (stdout, "Cleaning cache...\n");
purge (PURGE_ALL);
}
if (opt.purge)
{
fprintf (stdout, "Removing packages and sources...\n");
purge (PURGE_PKG);
}
putchar ('\n');
/* cleanup */
free_installed_t (&ginst, nginst);
pkg_t_free_all (&packages, packages_found);
for (i = (signed)N_REPOS - 1; i >= 0; i--)
{
free (REPOS[i].name);
free (REPOS[i].hostname);
free (REPOS[i].path);
}
free (REPOS);
free (opt.package);
free (opt.config);
free (opt.cache);
while ((opt.nblacklisted--) > 0)
{
regfree (&opt.blacklisted[opt.nblacklisted]);
}
free (opt.blacklisted);
return EXIT_SUCCESS;
}
void
ioproc0(void *v)
{
long n;
Mfile *mf;
uchar mdata[IOHDRSZ + Maxfdata];
Request req;
Job *job;
USED(v);
for(;;){
n = read9pmsg(mfd[0], mdata, sizeof mdata);
if(n <= 0){
syslog(0, logfile, "error reading mntpt: %r");
break;
}
job = newjob();
if(convM2S(mdata, n, &job->request) != n){
freejob(job);
continue;
}
if(debug)
syslog(0, logfile, "%F", &job->request);
getactivity(&req);
req.aborttime = now + 60; /* don't spend more than 60 seconds */
mf = nil;
switch(job->request.type){
case Tversion:
case Tauth:
case Tflush:
break;
case Tattach:
mf = newfid(job->request.fid, 1);
if(mf == nil){
sendmsg(job, "fid in use");
goto skip;
}
break;
default:
mf = newfid(job->request.fid, 0);
if(mf == nil){
sendmsg(job, "unknown fid");
goto skip;
}
break;
}
switch(job->request.type){
default:
syslog(1, logfile, "unknown request type %d", job->request.type);
break;
case Tversion:
rversion(job);
break;
case Tauth:
rauth(job);
break;
case Tflush:
rflush(job);
break;
case Tattach:
rattach(job, mf);
break;
case Twalk:
rwalk(job, mf);
break;
case Topen:
ropen(job, mf);
break;
case Tcreate:
rcreate(job, mf);
break;
case Tread:
rread(job, mf);
break;
case Twrite:
rwrite(job, mf, &req);
break;
case Tclunk:
rclunk(job, mf);
break;
case Tremove:
rremove(job, mf);
break;
case Tstat:
rstat(job, mf);
break;
case Twstat:
rwstat(job, mf);
break;
}
skip:
freejob(job);
putactivity();
}
}
void
rfServ_(int acceptSock)
{
static char fname[] = "rfServ_()";
struct LSFHeader msgHdr;
struct LSFHeader buf;
struct sockaddr_in from;
socklen_t fromLen = sizeof(from);
int sock;
XDR xdrs;
sock = accept(acceptSock, (struct sockaddr *)&from, &fromLen);
if (sock < 0) {
ls_errlog(stderr, I18N_FUNC_FAIL_MM, fname, "readDecodeHdr_");
closesocket(acceptSock);
return;
}
xdrmem_create(&xdrs, (char *) &buf, sizeof(buf), XDR_DECODE);
for (;;) {
XDR_SETPOS(&xdrs, 0);
if (readDecodeHdr_(sock,
(char *)&buf,
SOCK_READ_FIX,
&xdrs,
&msgHdr) < 0) {
ls_errlog(stderr, I18N_FUNC_FAIL_MM, fname, "readDecodeHdr_");
closesocket(sock);
xdr_destroy(&xdrs);
return;
}
switch (msgHdr.opCode) {
case RF_OPEN:
ropen(sock, &msgHdr);
break;
case RF_CLOSE:
rclose(sock, &msgHdr);
break;
case RF_WRITE:
rwrite(sock, &msgHdr);
break;
case RF_READ:
rread(sock, &msgHdr);
break;
case RF_STAT:
rstat(sock, &msgHdr);
break;
case RF_GETMNTHOST:
rgetmnthost(sock, &msgHdr);
break;
case RF_FSTAT:
rfstat(sock, &msgHdr);
break;
case RF_LSEEK:
rlseek(sock, &msgHdr);
break;
case RF_UNLINK:
runlink(sock, &msgHdr);
break;
case RF_TERMINATE:
closesocket(sock);
return;
default:
ls_errlog(stderr, _i18n_msg_get(ls_catd, NL_SETN, 602,
"%s: Unknown opcode %d"),
fname, msgHdr.opCode);
xdr_destroy(&xdrs);
break;
}
}
}
int main (int argc, char* argv[]) {
rstat d = rstat(argc,argv);
d.run ();
d. summarize();
}
static void
service(int cfd, int sfd, int dfd)
{
Fcall f;
int r;
Fid* fp;
fidpool = allocfidpool(nop);
for(;;){
fp = nil;
r = getfcall(cfd, &f);
if (r <= 0){
fprint(dfd, "trfs: getfcall %r\n");
break;
}
if(verbose)
fprint(dfd , "c→s %F\n", &f);
switch(f.type){
case Tclunk:
case Tremove:
// BUG in lib9p? removefid leaks fid.
// is that what it should do?
fp = lookupfid(fidpool, f.fid);
if (fp != nil){
removefid(fidpool, f.fid);
closefid(fp);
closefid(fp);
fp = nil;
}
break;
case Tcreate:
tcreate(&f);
// and also...
case Topen:
fp = allocfid(fidpool, f.fid);
fp->aux = 0;
break;
case Tread:
tread(&f);
break;
case Twalk:
twalk(&f);
break;
case Twstat:
twstat(&f);
break;
}
if(verbose && debug)
fprint(dfd , "c→s %F\n", &f);
if (putfcall(sfd, &f) < 0)
fprint(dfd , "can't putfcall: %r\n");
r = getfcall(sfd, &f);
if (r <= 0){
fprint(dfd, "trfs: 2nd getfcall %r\n");
break;
}
if (verbose)
fprint(dfd, "c←s %F\n", &f);
switch(f.type){
case Ropen:
case Rcreate:
fp->qid = f.qid;
break;
case Rread:
rread(&f);
break;
case Rstat:
rstat(&f);
break;
}
if(verbose && debug)
fprint(dfd , "c←s %F\n", &f);
if (putfcall(cfd, &f) < 0)
fprint(dfd , "can't 2n dputfcall: %r\n");
if (fp != nil)
closefid(fp);
}
}
bool
InetfsProperties::exists()
{
file_stat_t st;
return 0 == rstat(st);
}
