838 lines
13 KiB
C
838 lines
13 KiB
C
#include "u.h"
|
|
#include "lib.h"
|
|
#include "dat.h"
|
|
#include "fns.h"
|
|
#include "error.h"
|
|
|
|
Chan*
|
|
fdtochan(int fd, int mode, int chkmnt, int iref)
|
|
{
|
|
Fgrp *f;
|
|
Chan *c;
|
|
|
|
c = 0;
|
|
f = up->fgrp;
|
|
|
|
lock(&f->ref.lk);
|
|
if(fd<0 || NFD<=fd || (c = f->fd[fd])==0) {
|
|
unlock(&f->ref.lk);
|
|
error(Ebadfd);
|
|
}
|
|
if(iref)
|
|
refinc(&c->ref);
|
|
unlock(&f->ref.lk);
|
|
|
|
if(chkmnt && (c->flag&CMSG))
|
|
goto bad;
|
|
if(mode<0 || c->mode==ORDWR)
|
|
return c;
|
|
if((mode&OTRUNC) && c->mode==OREAD)
|
|
goto bad;
|
|
if((mode&~OTRUNC) != c->mode)
|
|
goto bad;
|
|
return c;
|
|
bad:
|
|
if(iref)
|
|
cclose(c);
|
|
error(Ebadusefd);
|
|
return nil; /* shut up compiler */
|
|
}
|
|
|
|
static void
|
|
fdclose(int fd, int flag)
|
|
{
|
|
int i;
|
|
Chan *c;
|
|
Fgrp *f;
|
|
|
|
f = up->fgrp;
|
|
|
|
lock(&f->ref.lk);
|
|
c = f->fd[fd];
|
|
if(c == 0) {
|
|
unlock(&f->ref.lk);
|
|
return;
|
|
}
|
|
if(flag) {
|
|
if(c==0 || !(c->flag&flag)) {
|
|
unlock(&f->ref.lk);
|
|
return;
|
|
}
|
|
}
|
|
f->fd[fd] = 0;
|
|
if(fd == f->maxfd)
|
|
for(i=fd; --i>=0 && f->fd[i]==0; )
|
|
f->maxfd = i;
|
|
|
|
unlock(&f->ref.lk);
|
|
cclose(c);
|
|
}
|
|
|
|
static int
|
|
newfd(Chan *c)
|
|
{
|
|
int i;
|
|
Fgrp *f;
|
|
|
|
f = up->fgrp;
|
|
lock(&f->ref.lk);
|
|
for(i=0; i<NFD; i++)
|
|
if(f->fd[i] == 0){
|
|
if(i > f->maxfd)
|
|
f->maxfd = i;
|
|
f->fd[i] = c;
|
|
unlock(&f->ref.lk);
|
|
return i;
|
|
}
|
|
unlock(&f->ref.lk);
|
|
error("no file descriptors");
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
sysclose(int fd)
|
|
{
|
|
if(waserror())
|
|
return -1;
|
|
|
|
fdtochan(fd, -1, 0, 0);
|
|
fdclose(fd, 0);
|
|
poperror();
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
syscreate(char *path, int mode, ulong perm)
|
|
{
|
|
int fd;
|
|
Chan *c = 0;
|
|
|
|
if(waserror()) {
|
|
cclose(c);
|
|
return -1;
|
|
}
|
|
|
|
openmode(mode); /* error check only */
|
|
c = namec(path, Acreate, mode, perm);
|
|
fd = newfd((Chan*)c);
|
|
poperror();
|
|
return fd;
|
|
}
|
|
|
|
int
|
|
sysdup(int old, int new)
|
|
{
|
|
Chan *oc;
|
|
Fgrp *f = up->fgrp;
|
|
Chan *c = 0;
|
|
|
|
if(waserror())
|
|
return -1;
|
|
|
|
c = fdtochan(old, -1, 0, 1);
|
|
if(new != -1) {
|
|
if(new < 0 || NFD <= new) {
|
|
cclose(c);
|
|
error(Ebadfd);
|
|
}
|
|
lock(&f->ref.lk);
|
|
if(new > f->maxfd)
|
|
f->maxfd = new;
|
|
oc = f->fd[new];
|
|
f->fd[new] = (Chan*)c;
|
|
unlock(&f->ref.lk);
|
|
if(oc != 0)
|
|
cclose(oc);
|
|
}
|
|
else {
|
|
if(waserror()) {
|
|
cclose(c);
|
|
nexterror();
|
|
}
|
|
new = newfd((Chan*)c);
|
|
poperror();
|
|
}
|
|
poperror();
|
|
return new;
|
|
}
|
|
|
|
int
|
|
sysfstat(int fd, char *buf)
|
|
{
|
|
Chan *c = 0;
|
|
|
|
if(waserror()) {
|
|
cclose(c);
|
|
return -1;
|
|
}
|
|
c = fdtochan(fd, -1, 0, 1);
|
|
devtab[c->type]->stat((Chan*)c, buf);
|
|
poperror();
|
|
cclose(c);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
sysfwstat(int fd, char *buf)
|
|
{
|
|
Chan *c = 0;
|
|
|
|
if(waserror()) {
|
|
cclose(c);
|
|
return -1;
|
|
}
|
|
nameok(buf);
|
|
c = fdtochan(fd, -1, 1, 1);
|
|
devtab[c->type]->wstat((Chan*)c, buf);
|
|
poperror();
|
|
cclose(c);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
syschdir(char *dir)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
long
|
|
bindmount(Chan *c0, char *old, int flag, char *spec)
|
|
{
|
|
int ret;
|
|
Chan *c1 = 0;
|
|
|
|
if(flag>MMASK || (flag&MORDER) == (MBEFORE|MAFTER))
|
|
error(Ebadarg);
|
|
|
|
c1 = namec(old, Amount, 0, 0);
|
|
if(waserror()){
|
|
cclose(c1);
|
|
nexterror();
|
|
}
|
|
|
|
ret = cmount(c0, c1, flag, spec);
|
|
|
|
poperror();
|
|
cclose(c1);
|
|
return ret;
|
|
}
|
|
|
|
int
|
|
sysbind(char *new, char *old, int flags)
|
|
{
|
|
long r;
|
|
Chan *c0 = 0;
|
|
|
|
if(waserror()) {
|
|
cclose(c0);
|
|
return -1;
|
|
}
|
|
c0 = namec(new, Aaccess, 0, 0);
|
|
r = bindmount(c0, old, flags, "");
|
|
poperror();
|
|
cclose(c0);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
sysmount(int fd, char *old, int flags, char *spec)
|
|
{
|
|
long r;
|
|
Chan *c0 = 0, *bc = 0;
|
|
struct {
|
|
Chan* chan;
|
|
char* spec;
|
|
int flags;
|
|
} mntparam;
|
|
|
|
if(waserror()) {
|
|
cclose(bc);
|
|
cclose(c0);
|
|
return -1;
|
|
}
|
|
bc = fdtochan(fd, ORDWR, 0, 1);
|
|
mntparam.chan = (Chan*)bc;
|
|
mntparam.spec = spec;
|
|
mntparam.flags = flags;
|
|
c0 = (*devtab[devno('M', 0)].attach)(&mntparam);
|
|
cclose(bc);
|
|
r = bindmount(c0, old, flags, spec);
|
|
poperror();
|
|
cclose(c0);
|
|
|
|
return r;
|
|
}
|
|
|
|
int
|
|
sysunmount(char *old, char *new)
|
|
{
|
|
Chan *cmount = 0, *cmounted = 0;
|
|
|
|
if(waserror()) {
|
|
cclose(cmount);
|
|
cclose(cmounted);
|
|
return -1;
|
|
}
|
|
|
|
cmount = namec(new, Amount, OREAD, 0);
|
|
if(old != 0)
|
|
cmounted = namec(old, Aopen, OREAD, 0);
|
|
|
|
cunmount(cmount, cmounted);
|
|
poperror();
|
|
cclose(cmount);
|
|
cclose(cmounted);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
sysopen(char *path, int mode)
|
|
{
|
|
int fd;
|
|
Chan *c = 0;
|
|
|
|
if(waserror()){
|
|
cclose(c);
|
|
return -1;
|
|
}
|
|
openmode(mode); /* error check only */
|
|
c = namec(path, Aopen, mode, 0);
|
|
fd = newfd((Chan*)c);
|
|
poperror();
|
|
return fd;
|
|
}
|
|
|
|
long
|
|
unionread(Chan *c, void *va, long n)
|
|
{
|
|
long nr;
|
|
Chan *nc = 0;
|
|
Pgrp *pg = 0;
|
|
|
|
pg = up->pgrp;
|
|
rlock(&pg->ns);
|
|
|
|
for(;;) {
|
|
if(waserror()) {
|
|
runlock(&pg->ns);
|
|
nexterror();
|
|
}
|
|
nc = clone(c->mnt->to, 0);
|
|
poperror();
|
|
|
|
if(c->mountid != c->mnt->mountid) {
|
|
runlock(&pg->ns);
|
|
cclose(nc);
|
|
return 0;
|
|
}
|
|
|
|
/* Error causes component of union to be skipped */
|
|
if(waserror()) {
|
|
cclose(nc);
|
|
goto next;
|
|
}
|
|
|
|
nc = (*devtab[nc->type].open)((Chan*)nc, OREAD);
|
|
nc->offset = c->offset;
|
|
nr = (*devtab[nc->type].read)((Chan*)nc, va, n, nc->offset);
|
|
/* devdirread e.g. changes it */
|
|
c->offset = nc->offset;
|
|
poperror();
|
|
|
|
cclose(nc);
|
|
if(nr > 0) {
|
|
runlock(&pg->ns);
|
|
return nr;
|
|
}
|
|
/* Advance to next element */
|
|
next:
|
|
c->mnt = c->mnt->next;
|
|
if(c->mnt == 0)
|
|
break;
|
|
c->mountid = c->mnt->mountid;
|
|
c->offset = 0;
|
|
}
|
|
runlock(&pg->ns);
|
|
return 0;
|
|
}
|
|
|
|
long
|
|
sysread(int fd, void *va, long n)
|
|
{
|
|
int dir;
|
|
Lock *cl;
|
|
Chan *c = 0;
|
|
|
|
if(waserror()) {
|
|
cclose(c);
|
|
return -1;
|
|
}
|
|
c = fdtochan(fd, OREAD, 1, 1);
|
|
|
|
dir = c->qid.path&CHDIR;
|
|
if(dir) {
|
|
n -= n%DIRLEN;
|
|
if(c->offset%DIRLEN || n==0)
|
|
error(Etoosmall);
|
|
}
|
|
|
|
if(dir && c->mnt)
|
|
n = unionread((Chan*)c, va, n);
|
|
else
|
|
n = (*devtab[c->type].read)((Chan*)c, va, n, c->offset);
|
|
|
|
cl = (Lock*)&c->r.l;
|
|
lock(cl);
|
|
c->offset += n;
|
|
unlock(cl);
|
|
|
|
poperror();
|
|
cclose(c);
|
|
|
|
return n;
|
|
}
|
|
|
|
int
|
|
sysremove(char *path)
|
|
{
|
|
Chan *c = 0;
|
|
|
|
if(waserror()) {
|
|
if(c != 0)
|
|
c->type = 0; /* see below */
|
|
cclose(c);
|
|
return -1;
|
|
}
|
|
c = namec(path, Aaccess, 0, 0);
|
|
(*devtab[c->type].remove)((Chan*)c);
|
|
/*
|
|
* Remove clunks the fid, but we need to recover the Chan
|
|
* so fake it up. rootclose() is known to be a nop.
|
|
*/
|
|
c->type = 0;
|
|
poperror();
|
|
cclose(c);
|
|
return 0;
|
|
}
|
|
|
|
long
|
|
sysseek(int fd, long off, int whence)
|
|
{
|
|
Dir dir;
|
|
Chan *c;
|
|
char buf[DIRLEN];
|
|
|
|
if(waserror())
|
|
return -1;
|
|
|
|
c = fdtochan(fd, -1, 1, 0);
|
|
if(c->qid.path & CHDIR)
|
|
error(Eisdir);
|
|
|
|
switch(whence) {
|
|
case 0:
|
|
c->offset = off;
|
|
break;
|
|
|
|
case 1:
|
|
lock(&c->r.l); /* lock for read/write update */
|
|
c->offset += off;
|
|
off = c->offset;
|
|
unlock(&c->r.l);
|
|
break;
|
|
|
|
case 2:
|
|
(*devtab[c->type].stat)(c, buf);
|
|
convM2D(buf, &dir);
|
|
c->offset = dir.length + off;
|
|
off = c->offset;
|
|
break;
|
|
}
|
|
poperror();
|
|
return off;
|
|
}
|
|
|
|
int
|
|
sysstat(char *path, char *buf)
|
|
{
|
|
Chan *c = 0;
|
|
|
|
if(waserror()){
|
|
cclose(c);
|
|
return -1;
|
|
}
|
|
c = namec(path, Aaccess, 0, 0);
|
|
(*devtab[c->type].stat)((Chan*)c, buf);
|
|
poperror();
|
|
cclose(c);
|
|
return 0;
|
|
}
|
|
|
|
long
|
|
syswrite(int fd, void *va, long n)
|
|
{
|
|
Lock *cl;
|
|
Chan *c = 0;
|
|
|
|
if(waserror()) {
|
|
cclose(c);
|
|
return -1;
|
|
}
|
|
c = fdtochan(fd, OWRITE, 1, 1);
|
|
if(c->qid.path & CHDIR)
|
|
error(Eisdir);
|
|
|
|
n = (*devtab[c->type].write)((Chan*)c, va, n, c->offset);
|
|
|
|
cl = (Lock*)&c->r.l;
|
|
lock(cl);
|
|
c->offset += n;
|
|
unlock(cl);
|
|
|
|
poperror();
|
|
cclose(c);
|
|
|
|
return n;
|
|
}
|
|
|
|
int
|
|
syswstat(char *path, char *buf)
|
|
{
|
|
Chan *c = 0;
|
|
|
|
if(waserror()) {
|
|
cclose(c);
|
|
return -1;
|
|
}
|
|
|
|
nameok(buf);
|
|
c = namec(path, Aaccess, 0, 0);
|
|
(*devtab[c->type].wstat)((Chan*)c, buf);
|
|
poperror();
|
|
cclose(c);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
sysdirstat(char *name, Dir *dir)
|
|
{
|
|
char buf[DIRLEN];
|
|
|
|
if(sysstat(name, buf) == -1)
|
|
return -1;
|
|
convM2D(buf, dir);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
sysdirfstat(int fd, Dir *dir)
|
|
{
|
|
char buf[DIRLEN];
|
|
|
|
if(sysfstat(fd, buf) == -1)
|
|
return -1;
|
|
|
|
convM2D(buf, dir);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
sysdirwstat(char *name, Dir *dir)
|
|
{
|
|
char buf[DIRLEN];
|
|
|
|
convD2M(dir, buf);
|
|
return syswstat(name, buf);
|
|
}
|
|
|
|
int
|
|
sysdirfwstat(int fd, Dir *dir)
|
|
{
|
|
char buf[DIRLEN];
|
|
|
|
convD2M(dir, buf);
|
|
return sysfwstat(fd, buf);
|
|
}
|
|
|
|
long
|
|
sysdirread(int fd, Dir *dbuf, long count)
|
|
{
|
|
int c, n, i, r;
|
|
char buf[DIRLEN*50];
|
|
|
|
n = 0;
|
|
count = (count/sizeof(Dir)) * DIRLEN;
|
|
while(n < count) {
|
|
c = count - n;
|
|
if(c > sizeof(buf))
|
|
c = sizeof(buf);
|
|
r = sysread(fd, buf, c);
|
|
if(r == 0)
|
|
break;
|
|
if(r < 0 || r % DIRLEN)
|
|
return -1;
|
|
for(i=0; i<r; i+=DIRLEN) {
|
|
convM2D(buf+i, dbuf);
|
|
dbuf++;
|
|
}
|
|
n += r;
|
|
if(r != c)
|
|
break;
|
|
}
|
|
|
|
return (n/DIRLEN) * sizeof(Dir);
|
|
}
|
|
|
|
static int
|
|
call(char *clone, char *dest, int *cfdp, char *dir, char *local)
|
|
{
|
|
int fd, cfd, n;
|
|
char *p, name[3*NAMELEN+5], data[3*NAMELEN+10];
|
|
|
|
cfd = sysopen(clone, ORDWR);
|
|
if(cfd < 0){
|
|
werrstr("%s: %r", clone);
|
|
return -1;
|
|
}
|
|
|
|
/* get directory name */
|
|
n = sysread(cfd, name, sizeof(name)-1);
|
|
if(n < 0) {
|
|
sysclose(cfd);
|
|
return -1;
|
|
}
|
|
name[n] = 0;
|
|
sprint(name, "%d", strtoul(name, 0, 0));
|
|
p = strrchr(clone, '/');
|
|
*p = 0;
|
|
if(dir)
|
|
snprint(dir, 2*NAMELEN, "%s/%s", clone, name);
|
|
snprint(data, sizeof(data), "%s/%s/data", clone, name);
|
|
|
|
/* connect */
|
|
/* set local side (port number, for example) if we need to */
|
|
if(local)
|
|
snprint(name, sizeof(name), "connect %s %s", dest, local);
|
|
else
|
|
snprint(name, sizeof(name), "connect %s", dest);
|
|
if(syswrite(cfd, name, strlen(name)) < 0){
|
|
werrstr("%s failed: %r", name);
|
|
sysclose(cfd);
|
|
return -1;
|
|
}
|
|
|
|
/* open data connection */
|
|
fd = sysopen(data, ORDWR);
|
|
if(fd < 0){
|
|
werrstr("can't open %s: %r", data);
|
|
sysclose(cfd);
|
|
return -1;
|
|
}
|
|
if(cfdp)
|
|
*cfdp = cfd;
|
|
else
|
|
sysclose(cfd);
|
|
return fd;
|
|
}
|
|
|
|
int
|
|
sysdial(char *dest, char *local, char *dir, int *cfdp)
|
|
{
|
|
int n, fd, rv;
|
|
char *p, net[128], clone[NAMELEN+12];
|
|
|
|
/* go for a standard form net!... */
|
|
p = strchr(dest, '!');
|
|
if(p == 0){
|
|
snprint(net, sizeof(net), "net!%s", dest);
|
|
} else {
|
|
strncpy(net, dest, sizeof(net)-1);
|
|
net[sizeof(net)-1] = 0;
|
|
}
|
|
|
|
/* call the connection server */
|
|
fd = sysopen("/net/cs", ORDWR);
|
|
if(fd < 0){
|
|
/* no connection server, don't translate */
|
|
p = strchr(net, '!');
|
|
*p++ = 0;
|
|
snprint(clone, sizeof(clone), "/net/%s/clone", net);
|
|
return call(clone, p, cfdp, dir, local);
|
|
}
|
|
|
|
/*
|
|
* send dest to connection to translate
|
|
*/
|
|
if(syswrite(fd, net, strlen(net)) < 0){
|
|
werrstr("%s: %r", net);
|
|
sysclose(fd);
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* loop through each address from the connection server till
|
|
* we get one that works.
|
|
*/
|
|
rv = -1;
|
|
sysseek(fd, 0, 0);
|
|
while((n = sysread(fd, net, sizeof(net) - 1)) > 0){
|
|
net[n] = 0;
|
|
p = strchr(net, ' ');
|
|
if(p == 0)
|
|
continue;
|
|
*p++ = 0;
|
|
rv = call(net, p, cfdp, dir, local);
|
|
if(rv >= 0)
|
|
break;
|
|
}
|
|
sysclose(fd);
|
|
return rv;
|
|
}
|
|
|
|
static int
|
|
identtrans(char *addr, char *naddr, int na, char *file, int nf)
|
|
{
|
|
char *p;
|
|
char reply[4*NAMELEN];
|
|
|
|
/* parse the network */
|
|
strncpy(reply, addr, sizeof(reply));
|
|
reply[sizeof(reply)-1] = 0;
|
|
p = strchr(reply, '!');
|
|
if(p)
|
|
*p++ = 0;
|
|
|
|
sprint(file, "/net/%.*s/clone", na - sizeof("/net//clone"), reply);
|
|
strncpy(naddr, p, na);
|
|
naddr[na-1] = 0;
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
nettrans(char *addr, char *naddr, int na, char *file, int nf)
|
|
{
|
|
long n;
|
|
int fd;
|
|
char *cp;
|
|
char reply[4*NAMELEN];
|
|
|
|
/*
|
|
* ask the connection server
|
|
*/
|
|
fd = sysopen("/net/cs", ORDWR);
|
|
if(fd < 0)
|
|
return identtrans(addr, naddr, na, file, nf);
|
|
if(syswrite(fd, addr, strlen(addr)) < 0){
|
|
sysclose(fd);
|
|
return -1;
|
|
}
|
|
sysseek(fd, 0, 0);
|
|
n = sysread(fd, reply, sizeof(reply)-1);
|
|
sysclose(fd);
|
|
if(n <= 0)
|
|
return -1;
|
|
reply[n] = '\0';
|
|
|
|
/*
|
|
* parse the reply
|
|
*/
|
|
cp = strchr(reply, ' ');
|
|
if(cp == 0)
|
|
return -1;
|
|
*cp++ = 0;
|
|
strncpy(naddr, cp, na);
|
|
naddr[na-1] = 0;
|
|
strncpy(file, reply, nf);
|
|
file[nf-1] = 0;
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
sysannounce(char *addr, char *dir)
|
|
{
|
|
char *cp;
|
|
int ctl, n, m;
|
|
char buf[3*NAMELEN];
|
|
char buf2[3*NAMELEN];
|
|
char netdir[2*NAMELEN];
|
|
char naddr[3*NAMELEN];
|
|
|
|
/*
|
|
* translate the address
|
|
*/
|
|
if(nettrans(addr, naddr, sizeof(naddr), netdir, sizeof(netdir)) < 0){
|
|
werrstr("can't translate address");
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* get a control channel
|
|
*/
|
|
ctl = sysopen(netdir, ORDWR);
|
|
if(ctl<0){
|
|
werrstr("can't open control channel");
|
|
return -1;
|
|
}
|
|
cp = strrchr(netdir, '/');
|
|
*cp = 0;
|
|
|
|
/*
|
|
* find out which line we have
|
|
*/
|
|
n = sprint(buf, "%.*s/", 2*NAMELEN+1, netdir);
|
|
m = sysread(ctl, &buf[n], sizeof(buf)-n-1);
|
|
if(m <= 0) {
|
|
sysclose(ctl);
|
|
werrstr("can't read control file");
|
|
return -1;
|
|
}
|
|
buf[n+m] = 0;
|
|
|
|
/*
|
|
* make the call
|
|
*/
|
|
n = sprint(buf2, "announce %.*s", 2*NAMELEN, naddr);
|
|
if(syswrite(ctl, buf2, n) != n) {
|
|
sysclose(ctl);
|
|
werrstr("announcement fails");
|
|
return -1;
|
|
}
|
|
|
|
strcpy(dir, buf);
|
|
|
|
return ctl;
|
|
}
|
|
|
|
int
|
|
syslisten(char *dir, char *newdir)
|
|
{
|
|
char *cp;
|
|
int ctl, n, m;
|
|
char buf[3*NAMELEN];
|
|
|
|
/*
|
|
* open listen, wait for a call
|
|
*/
|
|
sprint(buf, "%.*s/listen", 2*NAMELEN+1, dir);
|
|
ctl = sysopen(buf, ORDWR);
|
|
if(ctl < 0)
|
|
return -1;
|
|
|
|
/*
|
|
* find out which line we have
|
|
*/
|
|
strcpy(buf, dir);
|
|
cp = strrchr(buf, '/');
|
|
*++cp = 0;
|
|
n = cp-buf;
|
|
m = sysread(ctl, cp, sizeof(buf) - n - 1);
|
|
if(n<=0){
|
|
sysclose(ctl);
|
|
return -1;
|
|
}
|
|
buf[n+m] = 0;
|
|
|
|
strcpy(newdir, buf);
|
|
return ctl;
|
|
}
|