bool IsDir(const Stroka& path) { return isdir(path.c_str()) == 0; }
bool sbbs_t::pack_rep(uint hubnum) { char str[MAX_PATH+1]; char tmp[MAX_PATH+1],tmp2[MAX_PATH+1]; char hubid_upper[LEN_QWKID+1]; char hubid_lower[LEN_QWKID+1]; int file,mode; uint i,j,k; long msgcnt,submsgs,packedmail,netfiles=0,deleted; uint32_t u; uint32_t posts; uint32_t mailmsgs; ulong msgs; uint32_t last; post_t* post; mail_t* mail; FILE* rep; FILE* hdrs=NULL; DIR* dir; DIRENT* dirent; smbmsg_t msg; msgcnt=0L; delfiles(cfg.temp_dir,ALLFILES); SAFECOPY(hubid_upper,cfg.qhub[hubnum]->id); strupr(hubid_upper); SAFECOPY(hubid_lower,cfg.qhub[hubnum]->id); strlwr(hubid_lower); SAFEPRINTF2(str,"%s%s.REP",cfg.data_dir,hubid_upper); if(fexistcase(str)) { eprintf(LOG_INFO,"Updating %s", str); external(cmdstr(cfg.qhub[hubnum]->unpack,str,ALLFILES,NULL),EX_OFFLINE); } else eprintf(LOG_INFO,"Creating %s", str); /*************************************************/ /* Create SYSID.MSG, write header and leave open */ /*************************************************/ SAFEPRINTF2(str,"%s%s.MSG",cfg.temp_dir,hubid_upper); fexistcase(str); if((rep=fnopen(&file,str,O_CREAT|O_WRONLY|O_TRUNC))==NULL) { errormsg(WHERE,ERR_CREATE,str,O_CREAT|O_WRONLY|O_TRUNC); return(false); } if(filelength(file)<1) { /* New REP packet */ SAFEPRINTF2(str,"%-*s" ,QWK_BLOCK_LEN,hubid_upper); /* So write header */ fwrite(str,QWK_BLOCK_LEN,1,rep); } fseek(rep,0L,SEEK_END); /* Always includes HEADERS.DAT in .REP packets which are only for QWKnet hubs */ /* And *usually* a Synchronet system */ SAFEPRINTF(str,"%sHEADERS.DAT",cfg.temp_dir); fexistcase(str); if((hdrs=fopen(str,"a"))==NULL) errormsg(WHERE,ERR_CREATE,str,0); /*********************/ /* Pack new messages */ /*********************/ SAFEPRINTF(smb.file,"%smail",cfg.data_dir); smb.retry_time=cfg.smb_retry_time; smb.subnum=INVALID_SUB; if((i=smb_open(&smb))!=0) { fclose(rep); if(hdrs!=NULL) fclose(hdrs); errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error); return(false); } /***********************/ /* Pack E-mail, if any */ /***********************/ qwkmail_last=0; mail=loadmail(&smb,&mailmsgs,0,MAIL_YOUR,0); packedmail=0; if(mailmsgs) { eprintf(LOG_INFO,"Packing NetMail for %s", cfg.qhub[hubnum]->id); for(u=0;u<mailmsgs;u++) { // bprintf("\b\b\b\b\b%-5lu",u+1); memset(&msg,0,sizeof(msg)); msg.idx=mail[u]; if(msg.idx.number>qwkmail_last) qwkmail_last=msg.idx.number; if(!loadmsg(&msg,mail[u].number)) continue; SAFEPRINTF(str,"%s/",cfg.qhub[hubnum]->id); if(msg.to_net.type!=NET_QWK || (strcmp((char *)msg.to_net.addr,cfg.qhub[hubnum]->id) && strncmp((char *)msg.to_net.addr,str,strlen(str)))) { smb_unlockmsghdr(&smb,&msg); smb_freemsgmem(&msg); continue; } msgtoqwk(&msg,rep,QM_TO_QNET|QM_REP|A_LEAVE,INVALID_SUB,0,hdrs); packedmail++; smb_unlockmsghdr(&smb,&msg); smb_freemsgmem(&msg); YIELD(); /* yield */ } eprintf(LOG_INFO,"Packed %d NetMail messages",packedmail); } smb_close(&smb); /* Close the e-mail */ if(mailmsgs) free(mail); for(i=0;i<cfg.qhub[hubnum]->subs;i++) { j=cfg.qhub[hubnum]->sub[i]; /* j now equals the real sub num */ msgs=getlastmsg(j,&last,0); lncntr=0; /* defeat pause */ if(!msgs || last<=subscan[j].ptr) { if(subscan[j].ptr>last) { subscan[j].ptr=last; subscan[j].last=last; } eprintf(LOG_INFO,remove_ctrl_a(text[NScanStatusFmt],tmp) ,cfg.grp[cfg.sub[j]->grp]->sname ,cfg.sub[j]->lname,0L,msgs); continue; } SAFEPRINTF2(smb.file,"%s%s" ,cfg.sub[j]->data_dir,cfg.sub[j]->code); smb.retry_time=cfg.smb_retry_time; smb.subnum=j; if((k=smb_open(&smb))!=0) { errormsg(WHERE,ERR_OPEN,smb.file,k,smb.last_error); continue; } post=loadposts(&posts,j,subscan[j].ptr,LP_BYSELF|LP_OTHERS|LP_PRIVATE|LP_REP,NULL); eprintf(LOG_INFO,remove_ctrl_a(text[NScanStatusFmt],tmp) ,cfg.grp[cfg.sub[j]->grp]->sname ,cfg.sub[j]->lname,posts,msgs); if(!posts) { /* no new messages */ smb_close(&smb); continue; } subscan[j].ptr=last; /* set pointer */ eprintf(LOG_INFO,"%s",remove_ctrl_a(text[QWKPackingSubboard],tmp)); /* ptr to last msg */ submsgs=0; for(u=0;u<posts;u++) { // bprintf("\b\b\b\b\b%-5lu",u+1); memset(&msg,0,sizeof(msg)); msg.idx=post[u]; if(!loadmsg(&msg,post[u].number)) continue; if(msg.from_net.type && msg.from_net.type!=NET_QWK && !(cfg.sub[j]->misc&SUB_GATE)) { smb_freemsgmem(&msg); smb_unlockmsghdr(&smb,&msg); continue; } if(!strnicmp(msg.subj,"NE:",3) || (msg.from_net.type==NET_QWK && route_circ((char *)msg.from_net.addr,cfg.qhub[hubnum]->id))) { smb_freemsgmem(&msg); smb_unlockmsghdr(&smb,&msg); continue; } mode=cfg.qhub[hubnum]->mode[i]|QM_TO_QNET|QM_REP; if(mode&A_LEAVE) mode|=(QM_VIA|QM_TZ|QM_MSGID); if(msg.from_net.type!=NET_QWK) mode|=QM_TAGLINE; msgtoqwk(&msg,rep,mode,j,cfg.qhub[hubnum]->conf[i],hdrs); smb_freemsgmem(&msg); smb_unlockmsghdr(&smb,&msg); msgcnt++; submsgs++; if(!(u%50)) YIELD(); /* yield */ } eprintf(LOG_INFO,remove_ctrl_a(text[QWKPackedSubboard],tmp),submsgs,msgcnt); free(post); smb_close(&smb); YIELD(); /* yield */ } if(hdrs!=NULL) fclose(hdrs); fclose(rep); /* close HUB_ID.MSG */ CRLF; /* Look for extra files to send out */ SAFEPRINTF2(str,"%sqnet/%s.out",cfg.data_dir,hubid_lower); dir=opendir(str); while(dir!=NULL && (dirent=readdir(dir))!=NULL) { SAFEPRINTF3(str,"%sqnet/%s.out/%s",cfg.data_dir,hubid_lower,dirent->d_name); if(isdir(str)) continue; SAFEPRINTF2(tmp2,"%s%s",cfg.temp_dir,dirent->d_name); eprintf(LOG_INFO,remove_ctrl_a(text[RetrievingFile],tmp),str); if(!mv(str,tmp2,/* copy: */TRUE)) netfiles++; } if(dir!=NULL) closedir(dir); if(netfiles) CRLF; if(!msgcnt && !netfiles && !packedmail) { eprintf(LOG_INFO,remove_ctrl_a(text[QWKNoNewMessages],tmp)); return(true); // Changed from false Mar-11-2005 (needs to be true to save updated ptrs) } /*******************/ /* Compress Packet */ /*******************/ SAFEPRINTF2(str,"%s%s.REP",cfg.data_dir,hubid_upper); SAFEPRINTF2(tmp2,"%s%s",cfg.temp_dir,ALLFILES); i=external(cmdstr(cfg.qhub[hubnum]->pack,str,tmp2,NULL) ,EX_OFFLINE|EX_WILDCARD); if(!fexistcase(str)) { eprintf(LOG_WARNING,"%s",remove_ctrl_a(text[QWKCompressionFailed],tmp)); if(i) errormsg(WHERE,ERR_EXEC,cmdstr(cfg.qhub[hubnum]->pack,str,tmp2,NULL),i); else lprintf(LOG_ERR, "Couldn't compress REP packet"); return(false); } SAFEPRINTF2(str,"%sqnet/%s.out/",cfg.data_dir,hubid_lower); delfiles(str,ALLFILES); if(packedmail) { /* Delete NetMail */ SAFEPRINTF(smb.file,"%smail",cfg.data_dir); smb.retry_time=cfg.smb_retry_time; smb.subnum=INVALID_SUB; if((i=smb_open(&smb))!=0) { errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error); return(true); } mail=loadmail(&smb,&mailmsgs,0,MAIL_YOUR,0); if((i=smb_locksmbhdr(&smb))!=0) { /* Lock the base, so nobody */ if(mailmsgs) free(mail); smb_close(&smb); errormsg(WHERE,ERR_LOCK,smb.file,i,smb.last_error); /* messes with the index */ return(true); } if((i=smb_getstatus(&smb))!=0) { if(mailmsgs) free(mail); smb_close(&smb); errormsg(WHERE,ERR_READ,smb.file,i,smb.last_error); return(true); } deleted=0; /* Mark as READ and DELETE */ for(u=0;u<mailmsgs;u++) { if(mail[u].number>qwkmail_last) continue; memset(&msg,0,sizeof(msg)); /* !IMPORTANT: search by number (do not initialize msg.idx.offset) */ if(!loadmsg(&msg,mail[u].number)) continue; SAFEPRINTF(str,"%s/",cfg.qhub[hubnum]->id); if(msg.to_net.type!=NET_QWK || (strcmp((char *)msg.to_net.addr,cfg.qhub[hubnum]->id) && strncmp((char *)msg.to_net.addr,str,strlen(str)))) { smb_unlockmsghdr(&smb,&msg); smb_freemsgmem(&msg); continue; } msg.hdr.attr|=MSG_DELETE; msg.idx.attr=msg.hdr.attr; if((i=smb_putmsg(&smb,&msg))!=0) errormsg(WHERE,ERR_WRITE,smb.file,i,smb.last_error); else deleted++; smb_unlockmsghdr(&smb,&msg); smb_freemsgmem(&msg); } if(deleted && cfg.sys_misc&SM_DELEMAIL) delmail(0,MAIL_YOUR); smb_close(&smb); if(mailmsgs) free(mail); eprintf(LOG_INFO,"Deleted %d sent NetMail messages",deleted); } return(true); }
void main(int argc,String *argv) { String batname=Sconc(JPATH(),"/tmp/forall.bat"); ArgParser a=ArgParser(argc,argv); // a.comment("Syntax: forall <files> do <command>\n"); // a.comment(" or: forall in <filename> do <command>\n"); a.comment(" <command> may use %f as the filename,"); a.comment(" %s as the filename stripped of extensions,"); a.comment(" %e as the filename's extension,"); a.comment(" %l as %f in lower case,"); a.comment(" %L as %w in lower case,"); a.comment(" %w as the whole path of the filename,"); a.comment(" %n as the number of the file being processed,"); a.comment(" %a as & , %p as > , %q as \" ,"); a.comment(" and : to seperate commands."); #ifdef DOS a.comment(" For DOS, use $ instead of %"); #endif bool dirsonly=a.argexists("-dirsonly","execute command on directories only"); bool filesonly=a.argexists("-filesonly","execute command on non-directories only"); bool linkeddirsok=a.argexists("-followdirs","follow sym linked directories"); bool linkedfilesok=!a.argexists("-nofollowfiles","don't follow sym linked files"); bool showprogress=a.argexists("-showprog","show progress"); bool shell=a.argexists("-shell","run commands through a shell file"); a.comment(" A forall command in shell mode is not the same in non-shell mode"); a.comment(" since in the shell program the state will persist between each file."); bool ccomments =!a.argexists("-//","[in]: ignore // commenting"); bool shcomments=!a.argexists("-#"," [in]: ignore # commenting"); quiet=a.argexists("-stealth","don't print stuff"); int padzeros=a.intafter("-padzeros","pad %n with this many 0s on left",3); String padzeroformat=Sformat("%s0%ii","%",padzeros); bool checkforfilename=false; if (argc<3 || a.helpon) { a.com="forall <files> do <command> OR\nforall in <filename> do <command>"; a.helpon=true; a.done(); exit(0); } // Read files until do if (showprogress) printf("Files: "); List<String> fs; if (!Seq(a.arg(1),"in")) { // Files provided as arguments String s=""; while (!Seq(s,"do") && a.argsleft()) { s=a.getarg(1); if (!Seq(s,"do")) { if (showprogress) printf("%s ",s); boolean okay=true; // if (checkforfilename) // fs.add(getfiles(s)); // else /* if (!fileexists(s)) { if (!quiet) printf("Didn't find file %s\n",s); okay=false; }*/ if (isdir(s)) { if (filesonly) okay=false; if (islink(s) && !linkeddirsok) okay=false; } else { // not dir => file if (dirsonly) okay=false; if (islink(s) && !linkedfilesok) okay=false; } if ( (dirsonly || filesonly) && !fileexists(s) ) okay=false; if ((Sinstr(s,"*")>0) || (Sinstr(s,"?")>0)) { // Unresolved wildcard okay=false; if (!quiet) printf("forall: Did not find any \"%s\"\n",s); } if (Slen(s)==0) okay=false; if (okay) fs.add(s); } } } else { // Points to file containing list of files for forall String tmp=a.getarg(1); String fname=a.getarg(1); tmp=a.getarg(1); if (!Seq(tmp,"do")) error("Expected do in forall in <fname> do ..."); fs.add(readlinesfromfile(fname)); for (int i=1;i<=fs.len;i++) { String s=fs.num(i); if ( Slen(s)==0 || (dirsonly && !isdir(s)) || (filesonly && isdir(s)) || (ccomments && Sstarts(s,"//")) || (shcomments && Sstarts(s,"#")) ) { fs.removenumkeeporder(i); i--; } } if (showprogress) printf("%s ",fs.num(fs.len)); } if (showprogress) printf("\n"); // Read command after do if (showprogress) printf("Command: "); a.com=Sconc(a.com,"do <command> "); List<String> ls; while (a.argsleft()) { ls.add(Ssplitaround(a.getarg(1)," ")); if (showprogress) printf("\"%s\" ",ls.num(ls.len)); } if (showprogress) printf("\n"); if (ls.len==0) a.error("You must provide <command>"); a.done(); FILE *progress=NULL; progress=fopen("forall.progress","w"); List<String> coms; for (int i=1;i<=fs.len;i++) { String whole=fs.num(i); if (Slen(whole)>0) { String fname; int n=max(Sinstrlast(whole,"/"),Sinstrlast(whole,"\\")); if (n==0) fname=whole; else fname=Sfrom(whole,n+1); String strlow=Stolower(fname); String wholelow=Stolower(whole); /* Remove all '.'s int k; while ((k=Sinstr(str,"."))>0) { str=Sleft(str,k-1); } */ int k=Sinstrlast(fname,"."); String str=( k<=0 ? fname : Sleft(fname,k-1) ); String ext=( k<=0 ? Snew("") : Sfrom(fname,k+1) ); // List<String> coms; if (!shell) coms.clear(); String com=""; for (int j=1;j<=ls.len;j++) { String arg=ls.num(j); // if (showprogress) // printf("%s -> ",arg); #ifdef DOS arg=Sreplaceall(arg,"$n",Sformat(padzeroformat,i)); arg=Sreplaceall(arg,"$a","&"); arg=Sreplaceall(arg,"$f",fname); arg=Sreplaceall(arg,"$w",whole); arg=Sreplaceall(arg,"$s",str); arg=Sreplaceall(arg,"$e",ext); arg=Sreplaceall(arg,"$l",strlow); arg=Sreplaceall(arg,"$L",wholelow); arg=Sreplaceall(arg,"$p",">"); arg=Sreplaceall(arg,"$q","\""); #else arg=Sreplaceall(arg,"\%n",Sformat(padzeroformat,i)); arg=Sreplaceall(arg,"\%a","&"); arg=Sreplaceall(arg,"\%f",fname); arg=Sreplaceall(arg,"\%w",whole); arg=Sreplaceall(arg,"\%s",str); arg=Sreplaceall(arg,"\%e",ext); arg=Sreplaceall(arg,"\%l",strlow); arg=Sreplaceall(arg,"\%L",wholelow); arg=Sreplaceall(arg,"\%p",">"); arg=Sreplaceall(arg,"\%q","\""); #endif // if (showprogress) // printf("%s -> ",arg); if (Seq(arg,":")) { com=Srls(com); if (!quiet) { // printf("# (%03i/%i) %s\n",i,fs.len,com); String output=Sformat("# (%03i/%i) %s",i,fs.len,com); if (shell) // Print it later when the shell is being executed coms.add(Sconc("echo \"",Stoechoformat(output),"\"")); else printf("%s\n",output); } if (shell) coms.add(com); else system(com); com=""; } else com=Sconc(com," ",arg); /* if (showprogress) { printf("%s\n>",com); for (int k=1;k<=ls.len;k++) printf("%s ",ls.num(k)); printf("\n"); }*/ } com=Srls(com); if (!quiet) { String output=Sformat("# (%03i/%i) %s",i,fs.len,com); if (shell) // Print it later when the shell is being executed coms.add(Sconc("echo \"",Stoechoformat(output),"\"")); else printf("%s\n",output); } if (progress!=NULL) fprintf(progress,"-%03i/%i- %s\n",i,fs.len,com); if (shell) coms.add(com); else system(com); } }
static int amatch(char *s, char *p) { register int scc; int ok, lc; char *sgpathp; struct stat stb; int c, cc; globbed = 1; for (;;) { scc = *s++ & TRIM; switch (c = *p++) { case '{': return (execbrc(p - 1, s - 1)); case '[': ok = 0; lc = 077777; while ((cc = *p++)) { if (cc == ']') { if (ok) break; return (0); } if (cc == '-') { if (lc <= scc && scc <= *p++) ok++; } else if (scc == (lc = cc)) ok++; } if (cc == 0) { globerr = "Missing ]"; return (0); } continue; case '*': if (!*p) return (1); if (*p == '/') { p++; goto slash; } s--; do { if (amatch(s, p)) return (1); } while (*s++); return (0); case 0: return (scc == 0); default: if (c != scc) return (0); continue; case '?': if (scc == 0) return (0); continue; case '/': if (scc) return (0); slash: s = entp; sgpathp = gpathp; while (*s) addpath(*s++); addpath('/'); if (stat(gpath, &stb) == 0 && isdir(stb)) if (*p == 0) { Gcat(gpath, ""); globcnt++; } else expand(p); gpathp = sgpathp; *gpathp = 0; return (0); } } }
// install installs the library, package, or binary associated with dir, // which is relative to $GOROOT/src. static void install(char *dir) { char *name, *p, *elem, *prefix, *exe; bool islib, ispkg, isgo, stale, ispackcmd; Buf b, b1, path; Vec compile, files, link, go, missing, clean, lib, extra; Time ttarg, t; int i, j, k, n, doclean, targ; if(vflag) { if(!streq(goos, gohostos) || !streq(goarch, gohostarch)) errprintf("%s (%s/%s)\n", dir, goos, goarch); else errprintf("%s\n", dir); } binit(&b); binit(&b1); binit(&path); vinit(&compile); vinit(&files); vinit(&link); vinit(&go); vinit(&missing); vinit(&clean); vinit(&lib); vinit(&extra); // path = full path to dir. bpathf(&path, "%s/src/%s", goroot, dir); name = lastelem(dir); // For misc/prof, copy into the tool directory and we're done. if(hasprefix(dir, "misc/")) { copy(bpathf(&b, "%s/%s", tooldir, name), bpathf(&b1, "%s/misc/%s", goroot, name), 1); goto out; } // For release, cmd/prof is not included. if((streq(dir, "cmd/prof")) && !isdir(bstr(&path))) { if(vflag > 1) errprintf("skipping %s - does not exist\n", dir); goto out; } // set up gcc command line on first run. if(gccargs.len == 0) { bprintf(&b, "%s %s", defaultcc, defaultcflags); splitfields(&gccargs, bstr(&b)); for(i=0; i<nelem(proto_gccargs); i++) vadd(&gccargs, proto_gccargs[i]); if(defaultcflags[0] == '\0') { for(i=0; i<nelem(proto_gccargs2); i++) vadd(&gccargs, proto_gccargs2[i]); } if(contains(gccargs.p[0], "clang")) { // disable ASCII art in clang errors, if possible vadd(&gccargs, "-fno-caret-diagnostics"); // clang is too smart about unused command-line arguments vadd(&gccargs, "-Qunused-arguments"); } // disable word wrapping in error messages vadd(&gccargs, "-fmessage-length=0"); if(streq(gohostos, "darwin")) { // golang.org/issue/5261 vadd(&gccargs, "-mmacosx-version-min=10.6"); } } if(ldargs.len == 0 && defaultldflags[0] != '\0') { bprintf(&b, "%s", defaultldflags); splitfields(&ldargs, bstr(&b)); } islib = hasprefix(dir, "lib") || streq(dir, "cmd/cc") || streq(dir, "cmd/gc"); ispkg = hasprefix(dir, "pkg"); isgo = ispkg || streq(dir, "cmd/go") || streq(dir, "cmd/cgo"); exe = ""; if(streq(gohostos, "windows")) exe = ".exe"; // Start final link command line. // Note: code below knows that link.p[targ] is the target. ispackcmd = 0; if(islib) { // C library. vadd(&link, "ar"); if(streq(gohostos, "plan9")) vadd(&link, "rc"); else vadd(&link, "rsc"); prefix = ""; if(!hasprefix(name, "lib")) prefix = "lib"; targ = link.len; vadd(&link, bpathf(&b, "%s/pkg/obj/%s_%s/%s%s.a", goroot, gohostos, gohostarch, prefix, name)); } else if(ispkg) { // Go library (package). ispackcmd = 1; vadd(&link, "pack"); // program name - unused here, but all the other cases record one p = bprintf(&b, "%s/pkg/%s_%s/%s", goroot, goos, goarch, dir+4); *xstrrchr(p, '/') = '\0'; xmkdirall(p); targ = link.len; vadd(&link, bpathf(&b, "%s/pkg/%s_%s/%s.a", goroot, goos, goarch, dir+4)); } else if(streq(dir, "cmd/go") || streq(dir, "cmd/cgo")) { // Go command. vadd(&link, bpathf(&b, "%s/%sl", tooldir, gochar)); vadd(&link, "-o"); elem = name; if(streq(elem, "go")) elem = "go_bootstrap"; targ = link.len; vadd(&link, bpathf(&b, "%s/%s%s", tooldir, elem, exe)); } else { // C command. Use gccargs and ldargs. if(streq(gohostos, "plan9")) { vadd(&link, bprintf(&b, "%sl", gohostchar)); vadd(&link, "-o"); targ = link.len; vadd(&link, bpathf(&b, "%s/%s", tooldir, name)); } else { vcopy(&link, gccargs.p, gccargs.len); vcopy(&link, ldargs.p, ldargs.len); if(sflag) vadd(&link, "-static"); vadd(&link, "-o"); targ = link.len; vadd(&link, bpathf(&b, "%s/%s%s", tooldir, name, exe)); if(streq(gohostarch, "amd64")) vadd(&link, "-m64"); else if(streq(gohostarch, "386")) vadd(&link, "-m32"); } } ttarg = mtime(link.p[targ]); // Gather files that are sources for this target. // Everything in that directory, and any target-specific // additions. xreaddir(&files, bstr(&path)); // Remove files beginning with . or _, // which are likely to be editor temporary files. // This is the same heuristic build.ScanDir uses. // There do exist real C files beginning with _, // so limit that check to just Go files. n = 0; for(i=0; i<files.len; i++) { p = files.p[i]; if(hasprefix(p, ".") || (hasprefix(p, "_") && hassuffix(p, ".go"))) xfree(p); else files.p[n++] = p; } files.len = n; for(i=0; i<nelem(deptab); i++) { if(streq(dir, deptab[i].prefix) || (hassuffix(deptab[i].prefix, "/") && hasprefix(dir, deptab[i].prefix))) { for(j=0; (p=deptab[i].dep[j])!=nil; j++) { breset(&b1); bwritestr(&b1, p); bsubst(&b1, "$GOROOT", goroot); bsubst(&b1, "$GOOS", goos); bsubst(&b1, "$GOARCH", goarch); p = bstr(&b1); if(hassuffix(p, ".a")) { vadd(&lib, bpathf(&b, "%s", p)); continue; } if(hassuffix(p, "/*")) { bpathf(&b, "%s/%s", bstr(&path), p); b.len -= 2; xreaddir(&extra, bstr(&b)); bprintf(&b, "%s", p); b.len -= 2; for(k=0; k<extra.len; k++) vadd(&files, bpathf(&b1, "%s/%s", bstr(&b), extra.p[k])); continue; } if(hasprefix(p, "-")) { p++; n = 0; for(k=0; k<files.len; k++) { if(hasprefix(files.p[k], p)) xfree(files.p[k]); else files.p[n++] = files.p[k]; } files.len = n; continue; } vadd(&files, p); } } } vuniq(&files); // Convert to absolute paths. for(i=0; i<files.len; i++) { if(!isabs(files.p[i])) { bpathf(&b, "%s/%s", bstr(&path), files.p[i]); xfree(files.p[i]); files.p[i] = btake(&b); } } // Is the target up-to-date? stale = rebuildall; n = 0; for(i=0; i<files.len; i++) { p = files.p[i]; for(j=0; j<nelem(depsuffix); j++) if(hassuffix(p, depsuffix[j])) goto ok; xfree(files.p[i]); continue; ok: t = mtime(p); if(t != 0 && !hassuffix(p, ".a") && !shouldbuild(p, dir)) { xfree(files.p[i]); continue; } if(hassuffix(p, ".go")) vadd(&go, p); if(t > ttarg) stale = 1; if(t == 0) { vadd(&missing, p); files.p[n++] = files.p[i]; continue; } files.p[n++] = files.p[i]; } files.len = n; // If there are no files to compile, we're done. if(files.len == 0) goto out; for(i=0; i<lib.len && !stale; i++) if(mtime(lib.p[i]) > ttarg) stale = 1; if(!stale) goto out; // For package runtime, copy some files into the work space. if(streq(dir, "pkg/runtime")) { copy(bpathf(&b, "%s/arch_GOARCH.h", workdir), bpathf(&b1, "%s/arch_%s.h", bstr(&path), goarch), 0); copy(bpathf(&b, "%s/defs_GOOS_GOARCH.h", workdir), bpathf(&b1, "%s/defs_%s_%s.h", bstr(&path), goos, goarch), 0); p = bpathf(&b1, "%s/signal_%s_%s.h", bstr(&path), goos, goarch); if(isfile(p)) copy(bpathf(&b, "%s/signal_GOOS_GOARCH.h", workdir), p, 0); copy(bpathf(&b, "%s/os_GOOS.h", workdir), bpathf(&b1, "%s/os_%s.h", bstr(&path), goos), 0); copy(bpathf(&b, "%s/signals_GOOS.h", workdir), bpathf(&b1, "%s/signals_%s.h", bstr(&path), goos), 0); } // Generate any missing files; regenerate existing ones. for(i=0; i<files.len; i++) { p = files.p[i]; elem = lastelem(p); for(j=0; j<nelem(gentab); j++) { if(gentab[j].gen == nil) continue; if(hasprefix(elem, gentab[j].nameprefix)) { if(vflag > 1) errprintf("generate %s\n", p); gentab[j].gen(bstr(&path), p); // Do not add generated file to clean list. // In pkg/runtime, we want to be able to // build the package with the go tool, // and it assumes these generated files already // exist (it does not know how to build them). // The 'clean' command can remove // the generated files. goto built; } } // Did not rebuild p. if(find(p, missing.p, missing.len) >= 0) fatal("missing file %s", p); built:; } // One more copy for package runtime. // The last batch was required for the generators. // This one is generated. if(streq(dir, "pkg/runtime")) { copy(bpathf(&b, "%s/zasm_GOOS_GOARCH.h", workdir), bpathf(&b1, "%s/zasm_%s_%s.h", bstr(&path), goos, goarch), 0); } // Generate .c files from .goc files. if(streq(dir, "pkg/runtime")) { for(i=0; i<files.len; i++) { p = files.p[i]; if(!hassuffix(p, ".goc")) continue; // b = path/zp but with _goos_goarch.c instead of .goc bprintf(&b, "%s%sz%s", bstr(&path), slash, lastelem(p)); b.len -= 4; bwritef(&b, "_%s_%s.c", goos, goarch); goc2c(p, bstr(&b)); vadd(&files, bstr(&b)); } vuniq(&files); } if((!streq(goos, gohostos) || !streq(goarch, gohostarch)) && isgo) { // We've generated the right files; the go command can do the build. if(vflag > 1) errprintf("skip build for cross-compile %s\n", dir); goto nobuild; } // Compile the files. for(i=0; i<files.len; i++) { if(!hassuffix(files.p[i], ".c") && !hassuffix(files.p[i], ".s")) continue; name = lastelem(files.p[i]); vreset(&compile); if(!isgo) { // C library or tool. if(streq(gohostos, "plan9")) { vadd(&compile, bprintf(&b, "%sc", gohostchar)); vadd(&compile, "-FTVwp"); vadd(&compile, "-DPLAN9"); vadd(&compile, "-D__STDC__=1"); vadd(&compile, "-D__SIZE_TYPE__=ulong"); // for GNU Bison vadd(&compile, bpathf(&b, "-I%s/include/plan9", goroot)); vadd(&compile, bpathf(&b, "-I%s/include/plan9/%s", goroot, gohostarch)); } else { vcopy(&compile, gccargs.p, gccargs.len); vadd(&compile, "-c"); if(streq(gohostarch, "amd64")) vadd(&compile, "-m64"); else if(streq(gohostarch, "386")) vadd(&compile, "-m32"); vadd(&compile, "-I"); vadd(&compile, bpathf(&b, "%s/include", goroot)); } if(streq(dir, "lib9")) vadd(&compile, "-DPLAN9PORT"); vadd(&compile, "-I"); vadd(&compile, bstr(&path)); // lib9/goos.c gets the default constants hard-coded. if(streq(name, "goos.c")) { vadd(&compile, "-D"); vadd(&compile, bprintf(&b, "GOOS=\"%s\"", goos)); vadd(&compile, "-D"); vadd(&compile, bprintf(&b, "GOARCH=\"%s\"", goarch)); bprintf(&b1, "%s", goroot_final); bsubst(&b1, "\\", "\\\\"); // turn into C string vadd(&compile, "-D"); vadd(&compile, bprintf(&b, "GOROOT=\"%s\"", bstr(&b1))); vadd(&compile, "-D"); vadd(&compile, bprintf(&b, "GOVERSION=\"%s\"", goversion)); vadd(&compile, "-D"); vadd(&compile, bprintf(&b, "GOARM=\"%s\"", goarm)); vadd(&compile, "-D"); vadd(&compile, bprintf(&b, "GO386=\"%s\"", go386)); vadd(&compile, "-D"); vadd(&compile, bprintf(&b, "GO_EXTLINK_ENABLED=\"%s\"", goextlinkenabled)); } // gc/lex.c records the GOEXPERIMENT setting used during the build. if(streq(name, "lex.c")) { xgetenv(&b, "GOEXPERIMENT"); vadd(&compile, "-D"); vadd(&compile, bprintf(&b1, "GOEXPERIMENT=\"%s\"", bstr(&b))); } } else { // Supporting files for a Go package. if(hassuffix(files.p[i], ".s")) vadd(&compile, bpathf(&b, "%s/%sa", tooldir, gochar)); else { vadd(&compile, bpathf(&b, "%s/%sc", tooldir, gochar)); vadd(&compile, "-F"); vadd(&compile, "-V"); vadd(&compile, "-w"); } vadd(&compile, "-I"); vadd(&compile, workdir); vadd(&compile, "-I"); vadd(&compile, bprintf(&b, "%s/pkg/%s_%s", goroot, goos, goarch)); vadd(&compile, "-D"); vadd(&compile, bprintf(&b, "GOOS_%s", goos)); vadd(&compile, "-D"); vadd(&compile, bprintf(&b, "GOARCH_%s", goarch)); vadd(&compile, "-D"); vadd(&compile, bprintf(&b, "GOOS_GOARCH_%s_%s", goos, goarch)); } bpathf(&b, "%s/%s", workdir, lastelem(files.p[i])); doclean = 1; if(!isgo && streq(gohostos, "darwin")) { // To debug C programs on OS X, it is not enough to say -ggdb // on the command line. You have to leave the object files // lying around too. Leave them in pkg/obj/, which does not // get removed when this tool exits. bpathf(&b1, "%s/pkg/obj/%s", goroot, dir); xmkdirall(bstr(&b1)); bpathf(&b, "%s/%s", bstr(&b1), lastelem(files.p[i])); doclean = 0; } // Change the last character of the output file (which was c or s). if(streq(gohostos, "plan9")) b.p[b.len-1] = gohostchar[0]; else b.p[b.len-1] = 'o'; vadd(&compile, "-o"); vadd(&compile, bstr(&b)); vadd(&compile, files.p[i]); bgrunv(bstr(&path), CheckExit, &compile); vadd(&link, bstr(&b)); if(doclean) vadd(&clean, bstr(&b)); } bgwait(); if(isgo) { // The last loop was compiling individual files. // Hand the Go files to the compiler en masse. vreset(&compile); vadd(&compile, bpathf(&b, "%s/%sg", tooldir, gochar)); bpathf(&b, "%s/_go_.a", workdir); vadd(&compile, "-pack"); vadd(&compile, "-o"); vadd(&compile, bstr(&b)); vadd(&clean, bstr(&b)); if(!ispackcmd) vadd(&link, bstr(&b)); vadd(&compile, "-p"); if(hasprefix(dir, "pkg/")) vadd(&compile, dir+4); else vadd(&compile, "main"); if(streq(dir, "pkg/runtime")) vadd(&compile, "-+"); vcopy(&compile, go.p, go.len); runv(nil, bstr(&path), CheckExit, &compile); if(ispackcmd) { xremove(link.p[targ]); dopack(link.p[targ], bstr(&b), &link.p[targ+1], link.len - (targ+1)); goto nobuild; } } if(!islib && !isgo) { // C binaries need the libraries explicitly, and -lm. vcopy(&link, lib.p, lib.len); if(!streq(gohostos, "plan9")) vadd(&link, "-lm"); } // Remove target before writing it. xremove(link.p[targ]); runv(nil, nil, CheckExit, &link); nobuild: // In package runtime, we install runtime.h and cgocall.h too, // for use by cgo compilation. if(streq(dir, "pkg/runtime")) { copy(bpathf(&b, "%s/pkg/%s_%s/cgocall.h", goroot, goos, goarch), bpathf(&b1, "%s/src/pkg/runtime/cgocall.h", goroot), 0); copy(bpathf(&b, "%s/pkg/%s_%s/runtime.h", goroot, goos, goarch), bpathf(&b1, "%s/src/pkg/runtime/runtime.h", goroot), 0); } out: for(i=0; i<clean.len; i++) xremove(clean.p[i]); bfree(&b); bfree(&b1); bfree(&path); vfree(&compile); vfree(&files); vfree(&link); vfree(&go); vfree(&missing); vfree(&clean); vfree(&lib); vfree(&extra); }
static int deep_remove_dir (const char *path) { DIR *dirp; struct dirent *dp; if (rmdir (path) != 0) { if (errno == ENOTEMPTY || errno == EEXIST /* Ugly workaround for ugly AIX 4.1 (and 3.2) header bug (it defines ENOTEMPTY and EEXIST to 17 but actually returns 87). */ || (ENOTEMPTY == 17 && EEXIST == 17 && errno == 87)) { if ((dirp = CVS_OPENDIR (path)) == NULL) /* If unable to open the directory return * an error */ return -1; errno = 0; while ((dp = CVS_READDIR (dirp)) != NULL) { char *buf; if (strcmp (dp->d_name, ".") == 0 || strcmp (dp->d_name, "..") == 0) continue; buf = Xasprintf ("%s/%s", path, dp->d_name); /* See comment in unlink_file_dir explanation of why we use isdir instead of just calling unlink and checking the status. */ if (isdir (buf)) { if (deep_remove_dir (buf)) { CVS_CLOSEDIR (dirp); free (buf); return -1; } } else { if (CVS_UNLINK (buf) != 0) { CVS_CLOSEDIR (dirp); free (buf); return -1; } } free (buf); errno = 0; } if (errno != 0) { int save_errno = errno; CVS_CLOSEDIR (dirp); errno = save_errno; return -1; } CVS_CLOSEDIR (dirp); return rmdir (path); } else return -1; } /* Was able to remove the directory return 0 */ return 0; }
/* * Delete the results of a package installation. * * This is here rather than in the pkg_delete code because pkg_add needs to * run it too in cases of failure. */ int delete_package(Boolean ign_err, package_t *pkg, Boolean NoDeleteFiles, const char *destdir) { plist_t *p; const char *last_file = ""; int fail = SUCCESS; Boolean preserve; char tmp[MaxPathSize]; const char *prefix = NULL, *name = NULL; if (!pkgdb_open(ReadWrite)) { err(EXIT_FAILURE, "cannot open pkgdb"); } preserve = find_plist_option(pkg, "preserve") ? TRUE : FALSE; for (p = pkg->head; p; p = p->next) { switch (p->type) { case PLIST_NAME: name = p->name; break; case PLIST_CWD: if (prefix == NULL) prefix = p->name; break; default: break; } } if (name == NULL || prefix == NULL) errx(EXIT_FAILURE, "broken PLIST"); /* * Remove database entries first, directory removal is done * in the main loop below. */ for (p = pkg->head; p; p = p->next) { if (p->type == PLIST_PKGDIR) delete_pkgdir(name, prefix, p->name); } for (p = pkg->head; p; p = p->next) { switch (p->type) { case PLIST_NAME: /* Handled already */ break; case PLIST_PKGDIR: case PLIST_DIR_RM: (void) snprintf(tmp, sizeof(tmp), "%s/%s", prefix, p->name); if (has_pkgdir(tmp)) continue; (void) snprintf(tmp, sizeof(tmp), "%s%s%s/%s", destdir ? destdir : "", destdir ? "/" : "", prefix, p->name); if (!fexists(tmp)) { if (p->type == PLIST_PKGDIR) warnx("Directory `%s' disappeared, skipping", tmp); } else if (!isdir(tmp)) { warnx("attempting to delete a file `%s' as a directory\n" "this packing list is incorrect - ignoring delete request", tmp); } else if (delete_with_parents(tmp, ign_err, TRUE)) fail = FAIL; break; case PLIST_IGNORE: p = p->next; break; case PLIST_UNEXEC: if (NoDeleteFiles) break; format_cmd(tmp, sizeof(tmp), p->name, prefix, last_file); printf("Executing `%s'\n", tmp); if (!Fake && system(tmp)) { warnx("unexec command for `%s' failed", tmp); fail = FAIL; } break; case PLIST_FILE: last_file = p->name; (void) snprintf(tmp, sizeof(tmp), "%s%s%s/%s", destdir ? destdir : "", destdir ? "/" : "", prefix, p->name); if (isdir(tmp)) { warnx("attempting to delete directory `%s' as a file\n" "this packing list is incorrect - ignoring delete request", tmp); } else { int restored = 0; /* restored from preserve? */ if (p->next && p->next->type == PLIST_COMMENT) { if (strncmp(p->next->name, CHECKSUM_HEADER, ChecksumHeaderLen) == 0) { char *cp, buf[LegibleChecksumLen]; if ((cp = MD5File(tmp, buf)) != NULL) { /* Mismatch? */ if (strcmp(cp, p->next->name + ChecksumHeaderLen) != 0) { printf("original MD5 checksum failed, %s: %s\n", Force ? "deleting anyway" : "not deleting", tmp); if (!Force) { fail = FAIL; goto pkgdb_cleanup; } } } } else if (strncmp(p->next->name, SYMLINK_HEADER, SymlinkHeaderLen) == 0) { char buf[MaxPathSize + SymlinkHeaderLen]; int cc; (void) strlcpy(buf, SYMLINK_HEADER, sizeof(buf)); if ((cc = readlink(tmp, &buf[SymlinkHeaderLen], sizeof(buf) - SymlinkHeaderLen - 1)) < 0) { warn("can't readlink `%s'", tmp); goto pkgdb_cleanup; } buf[SymlinkHeaderLen + cc] = 0x0; if (strcmp(buf, p->next->name) != 0) { if ((cc = readlink(&buf[SymlinkHeaderLen], &buf[SymlinkHeaderLen], sizeof(buf) - SymlinkHeaderLen)) < 0) { printf("symlink %s is not same as recorded value, %s: %s\n", buf, Force ? "deleting anyway" : "not deleting", tmp); if (!Force) { fail = FAIL; goto pkgdb_cleanup; } } buf[SymlinkHeaderLen + cc] = 0x0; if (strcmp(buf, p->next->name) != 0) { printf("symlink %s is not same as recorded value, %s: %s\n", buf, Force ? "deleting anyway" : "not deleting", tmp); if (!Force) { fail = FAIL; goto pkgdb_cleanup; } } } } } if (Verbose && !NoDeleteFiles) printf("Delete file %s\n", tmp); if (!Fake && !NoDeleteFiles) { if (delete_with_parents(tmp, ign_err, FALSE)) fail = FAIL; if (preserve && name) { char tmp2[MaxPathSize]; if (make_preserve_name(tmp2, MaxPathSize, name, tmp)) { if (fexists(tmp2)) { if (rename(tmp2, tmp)) warn("preserve: unable to restore %s as %s", tmp2, tmp); else restored = 1; } } } } pkgdb_cleanup: if (!Fake) { if (!restored) { errno = 0; if (pkgdb_remove(tmp) && errno) perror("pkgdb_remove"); } } } break; default: break; } } pkgdb_close(); return fail; }
int main(int argc, char **argv) { char str[MAX_PATH+1]; char fname[MAX_PATH+1]; char ini_fname[MAX_PATH+1]; char* p; char* arg; int i; int retval; uint fnames=0; FILE* fp; BOOL tcp_nodelay; char compiler[32]; str_list_t fname_list; fname_list=strListInit(); DESCRIBE_COMPILER(compiler); errfp=stderr; #ifdef __unix__ statfp=stderr; #else statfp=stdout; #endif sscanf("$Revision: 1.77 $", "%*s %s", revision); fprintf(statfp,"\nSynchronet External X/Y/Zmodem v%s-%s" " Copyright %s Rob Swindell\n\n" ,revision ,PLATFORM_DESC ,__DATE__+7 ); xmodem_init(&xm,NULL,&mode,lputs,xmodem_progress,send_byte,recv_byte,is_connected,NULL); zmodem_init(&zm,NULL,lputs,zmodem_progress,send_byte,recv_byte,is_connected,NULL,data_waiting); /* Generate path/sexyz[.host].ini from path/sexyz[.exe] */ SAFECOPY(str,argv[0]); p=getfname(str); SAFECOPY(fname,p); *p=0; if((p=getfext(fname))!=NULL) *p=0; strcat(fname,".ini"); iniFileName(ini_fname,sizeof(ini_fname),str,fname); if((fp=fopen(ini_fname,"r"))!=NULL) fprintf(statfp,"Reading %s\n",ini_fname); tcp_nodelay =iniReadBool(fp,ROOT_SECTION,"TCP_NODELAY",TRUE); telnet =iniReadBool(fp,ROOT_SECTION,"Telnet",TRUE); debug_tx =iniReadBool(fp,ROOT_SECTION,"DebugTx",FALSE); debug_rx =iniReadBool(fp,ROOT_SECTION,"DebugRx",FALSE); debug_telnet =iniReadBool(fp,ROOT_SECTION,"DebugTelnet",FALSE); pause_on_exit =iniReadBool(fp,ROOT_SECTION,"PauseOnExit",FALSE); pause_on_abend =iniReadBool(fp,ROOT_SECTION,"PauseOnAbend",FALSE); log_level =iniReadLogLevel(fp,ROOT_SECTION,"LogLevel",log_level); outbuf.highwater_mark =iniReadInteger(fp,ROOT_SECTION,"OutbufHighwaterMark",1100); outbuf_drain_timeout =iniReadInteger(fp,ROOT_SECTION,"OutbufDrainTimeout",10); outbuf_size =iniReadInteger(fp,ROOT_SECTION,"OutbufSize",16*1024); progress_interval =iniReadInteger(fp,ROOT_SECTION,"ProgressInterval",1); if(iniReadBool(fp,ROOT_SECTION,"Debug",FALSE)) log_level=LOG_DEBUG; xm.send_timeout =iniReadInteger(fp,"Xmodem","SendTimeout",xm.send_timeout); /* seconds */ xm.recv_timeout =iniReadInteger(fp,"Xmodem","RecvTimeout",xm.recv_timeout); /* seconds */ xm.byte_timeout =iniReadInteger(fp,"Xmodem","ByteTimeout",xm.byte_timeout); /* seconds */ xm.ack_timeout =iniReadInteger(fp,"Xmodem","AckTimeout",xm.ack_timeout); /* seconds */ xm.block_size =iniReadInteger(fp,"Xmodem","BlockSize",xm.block_size); /* 128 or 1024 */ xm.max_errors =iniReadInteger(fp,"Xmodem","MaxErrors",xm.max_errors); xm.g_delay =iniReadInteger(fp,"Xmodem","G_Delay",xm.g_delay); zm.init_timeout =iniReadInteger(fp,"Zmodem","InitTimeout",zm.init_timeout); /* seconds */ zm.send_timeout =iniReadInteger(fp,"Zmodem","SendTimeout",zm.send_timeout); /* seconds */ zm.recv_timeout =iniReadInteger(fp,"Zmodem","RecvTimeout",zm.recv_timeout); /* seconds */ zm.crc_timeout =iniReadInteger(fp,"Zmodem","CrcTimeout",zm.crc_timeout); /* seconds */ zm.block_size =iniReadInteger(fp,"Zmodem","BlockSize",zm.block_size); /* 1024 */ zm.max_block_size =iniReadInteger(fp,"Zmodem","MaxBlockSize",zm.max_block_size); /* 1024 or 8192 */ zm.max_errors =iniReadInteger(fp,"Zmodem","MaxErrors",zm.max_errors); zm.recv_bufsize =iniReadInteger(fp,"Zmodem","RecvBufSize",0); zm.no_streaming =!iniReadBool(fp,"Zmodem","Streaming",TRUE); zm.want_fcs_16 =!iniReadBool(fp,"Zmodem","CRC32",TRUE); zm.escape_telnet_iac =iniReadBool(fp,"Zmodem","EscapeTelnetIAC",TRUE); zm.escape_8th_bit =iniReadBool(fp,"Zmodem","Escape8thBit",FALSE); zm.escape_ctrl_chars =iniReadBool(fp,"Zmodem","EscapeCtrlChars",FALSE); dszlog_path =iniReadBool(fp,"DSZLOG","Path",TRUE); dszlog_short =iniReadBool(fp,"DSZLOG","Short",FALSE); dszlog_quotes =iniReadBool(fp,"DSZLOG","Quotes",FALSE); if(fp!=NULL) fclose(fp); if(zm.recv_bufsize > 0xffff) zm.recv_bufsize = 0xffff; if(outbuf_size < MIN_OUTBUF_SIZE) outbuf_size = MIN_OUTBUF_SIZE; else if(outbuf_size > MAX_OUTBUF_SIZE) outbuf_size = MAX_OUTBUF_SIZE; fprintf(statfp,"Output buffer size: %u\n", outbuf_size); RingBufInit(&outbuf, outbuf_size); #if !defined(RINGBUF_EVENT) outbuf_empty=CreateEvent(NULL,/* ManualReset */TRUE, /*InitialState */TRUE,NULL); #endif #if 0 if(argc>1) { fprintf(statfp,"Command line: "); for(i=1;i<argc;i++) fprintf(statfp,"%s ",argv[i]); fprintf(statfp,"\n",statfp); } #endif for(i=1;i<argc;i++) { if(sock==INVALID_SOCKET && isdigit(argv[i][0])) { sock=atoi(argv[i]); continue; } if(!(mode&(SEND|RECV))) { if(toupper(argv[i][0])=='S' || toupper(argv[i][0])=='R') { /* cmd */ if(toupper(argv[i][0])=='R') mode|=RECV; else mode|=SEND; switch(argv[i][1]) { case 'c': case 'C': mode|=XMODEM|CRC; break; case 'x': xm.block_size=128; case 'X': mode|=XMODEM; break; case 'b': /* sz/rz compatible */ case 'B': case 'y': xm.block_size=128; case 'Y': mode|=(YMODEM|CRC); break; case 'g': case 'G': mode|=(YMODEM|CRC|GMODE); break; case 'z': case 'Z': mode|=(ZMODEM|CRC); break; default: fprintf(statfp,"Unrecognized command '%s'\n\n",argv[i]); fprintf(statfp,usage); bail(1); } continue; } if(toupper(argv[i][0])=='V') { fprintf(statfp,"%-8s %s\n",getfname(__FILE__) ,revision); fprintf(statfp,"%-8s %s\n",getfname(xmodem_source()),xmodem_ver(str)); fprintf(statfp,"%-8s %s\n",getfname(zmodem_source()),zmodem_ver(str)); #ifdef _DEBUG fprintf(statfp,"Debug\n"); #endif fprintf(statfp,"Compiled %s %.5s with %s\n",__DATE__,__TIME__,compiler); fprintf(statfp,"%s\n",os_version(str)); bail(0); } arg=argv[i]; if(*arg=='-') { while(*arg=='-') arg++; if(stricmp(arg,"telnet")==0) { telnet=TRUE; continue; } if(stricmp(arg,"rlogin")==0 || stricmp(arg,"ssh")==0 || stricmp(arg,"raw")==0) { telnet=FALSE; continue; } if(stricmp(arg,"debug")==0) { log_level=LOG_DEBUG; continue; } if(stricmp(arg,"quotes")==0) { dszlog_quotes=TRUE; continue; } switch(toupper(*arg)) { case 'K': /* sz/rz compatible */ xm.block_size=1024; break; case 'C': /* sz/rz compatible */ mode|=CRC; break; case '2': zm.max_block_size=2048; break; case '4': zm.max_block_size=4096; break; case '8': /* ZedZap */ zm.max_block_size=8192; break; case 'O': /* disable Zmodem CRC-32 */ zm.want_fcs_16=TRUE; break; case 'S': /* disable Zmodem streaming */ zm.no_streaming=TRUE; break; case 'G': /* Ymodem-G */ mode|=GMODE; break; case 'Y': mode|=OVERWRITE; break; case '!': pause_on_abend=TRUE; break; } } } else if((argv[i][0]=='+' || argv[i][0]=='@') && fexist(argv[i]+1)) { if(mode&RECVDIR) { fprintf(statfp,"!Cannot specify both directory and filename\n"); bail(1); } sprintf(str,"%s",argv[i]+1); if((fp=fopen(str,"r"))==NULL) { fprintf(statfp,"!Error %d opening filelist: %s\n",errno,str); bail(1); } while(!feof(fp) && !ferror(fp)) { if(!fgets(str,sizeof(str),fp)) break; truncsp(str); strListAppend(&fname_list,strdup(str),fnames++); } fclose(fp); } else if(mode&(SEND|RECV)){ if(isdir(argv[i])) { /* is a directory */ if(mode&RECVDIR) { fprintf(statfp,"!Only one directory can be specified\n"); bail(1); } if(fnames) { fprintf(statfp,"!Cannot specify both directory and filename\n"); bail(1); } if(mode&SEND) { fprintf(statfp,"!Cannot send directory '%s'\n",argv[i]); bail(1); } mode|=RECVDIR; } strListAppend(&fname_list,argv[i],fnames++); } } if(!telnet) zm.escape_telnet_iac = FALSE; if(sock==INVALID_SOCKET || sock<1) { #ifdef __unix__ if(STDOUT_FILENO > STDIN_FILENO) sock=STDOUT_FILENO; else sock=STDIN_FILENO; stdio=TRUE; fprintf(statfp,"No socket descriptor specified, using STDIO\n"); telnet=FALSE; #else fprintf(statfp,"!No socket descriptor specified\n\n"); fprintf(errfp,usage); bail(1); #endif } #ifdef __unix__ else statfp=stdout; #endif if(!(mode&(SEND|RECV))) { fprintf(statfp,"!No command specified\n\n"); fprintf(statfp,usage); bail(1); } if(mode&(SEND|XMODEM) && !fnames) { /* Sending with any or recv w/Xmodem */ fprintf(statfp,"!Must specify filename or filelist\n\n"); fprintf(statfp,usage); bail(1); } #ifdef __unix__ if(stdio) { struct termios term; memset(&term,0,sizeof(term)); cfsetispeed(&term,B19200); cfsetospeed(&term,B19200); term.c_iflag &= ~(IMAXBEL|IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON); term.c_oflag &= ~OPOST; term.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN); term.c_cflag &= ~(CSIZE|PARENB); term.c_cflag |= CS8; atexit(resetterm); tcgetattr(STDOUT_FILENO, &origterm); tcsetattr(STDOUT_FILENO, TCSADRAIN, &term); } #endif /* Code disabled. Why? ToDo */ /* if(mode&RECVDIR) backslash(fname[0]); */ if(!winsock_startup()) bail(-1); /* Enable the Nagle Algorithm */ #ifdef __unix__ if(!stdio) { #endif lprintf(LOG_DEBUG,"Setting TCP_NODELAY to %d",tcp_nodelay); setsockopt(sock,IPPROTO_TCP,TCP_NODELAY,(char*)&tcp_nodelay,sizeof(tcp_nodelay)); #ifdef __unix__ } #endif if(!socket_check(sock, NULL, NULL, 0)) { lprintf(LOG_WARNING,"No socket connection"); bail(-1); } if((dszlog=getenv("DSZLOG"))!=NULL) { if((logfp=fopen(dszlog,"w"))==NULL) { lprintf(LOG_WARNING,"Error %d opening DSZLOG file: %s",errno,dszlog); bail(-1); } } /* Install Ctrl-C/Break signal handler here */ #if defined(_WIN32) SetConsoleCtrlHandler(ControlHandler, TRUE /* Add */); #elif defined(__unix__) signal(SIGQUIT,break_handler); signal(SIGINT,break_handler); signal(SIGTERM,break_handler); signal(SIGHUP,SIG_IGN); /* Don't die on SIGPIPE */ signal(SIGPIPE,SIG_IGN); #endif #if !SINGLE_THREADED _beginthread(output_thread,0,NULL); #endif if(mode&RECV) retval=receive_files(fname_list, fnames); else retval=send_files(fname_list, fnames); #if !SINGLE_THREADED lprintf(LOG_DEBUG,"Waiting for output buffer to empty... "); if(WaitForEvent(outbuf_empty,5000)!=WAIT_OBJECT_0) lprintf(LOG_DEBUG,"FAILURE"); #endif terminate=TRUE; /* stop output thread */ /* Code disabled. Why? ToDo */ /* sem_post(outbuf.sem); sem_post(outbuf.highwater_sem); */ fprintf(statfp,"Exiting - Error level: %d, flows: %u, select_errors=%u" ,retval, flows, select_errors); fprintf(statfp,"\n"); bail(retval); }
static int send_files(char** fname, uint fnames) { char path[MAX_PATH+1]; int i; uint errors; uint fnum; uint cps; glob_t g; int gi; BOOL success=TRUE; long fsize; ulong sent_bytes; ulong total_bytes=0; time_t t,startfile; time_t startall; FILE* fp; startall=time(NULL); /****************************************************/ /* Search through all to find total files and bytes */ /****************************************************/ for(fnum=0;fnum<fnames;fnum++) { if(glob(fname[fnum],0,NULL,&g)) { lprintf(LOG_WARNING,"%s not found",fname[fnum]); continue; } for(i=0;i<(int)g.gl_pathc;i++) { if(isdir(g.gl_pathv[i])) continue; xm.total_files++; xm.total_bytes+=flength(g.gl_pathv[i]); } globfree(&g); } if(xm.total_files<1) { lprintf(LOG_ERR,"No files to send"); return(-1); } if(xm.total_files>1) lprintf(LOG_INFO,"Sending %u files (%lu KB total)" ,xm.total_files,xm.total_bytes/1024); zm.files_remaining = xm.total_files; zm.bytes_remaining = xm.total_bytes; /***********************************************/ /* Send every file matching names or filespecs */ /***********************************************/ for(fnum=0;fnum<fnames;fnum++) { if(glob(fname[fnum],0,NULL,&g)) { lprintf(LOG_WARNING,"%s not found",fname[fnum]); continue; } for(gi=0;gi<(int)g.gl_pathc;gi++) { SAFECOPY(path,g.gl_pathv[gi]); if(isdir(path)) continue; if((fp=fnopen(NULL,path,O_RDONLY|O_BINARY))==NULL && (fp=fopen(path,"rb"))==NULL) { lprintf(LOG_ERR,"Error %d opening %s for read",errno,path); continue; } setvbuf(fp,NULL,_IOFBF,0x10000); fsize=filelength(fileno(fp)); errors=0; success=FALSE; startfile=time(NULL); lprintf(LOG_INFO,"Sending %s (%lu KB) via %s" ,path,fsize/1024 ,mode&XMODEM ? "Xmodem" : mode&YMODEM ? "Ymodem" : "Zmodem"); if(mode&ZMODEM) success=zmodem_send_file(&zm, path, fp, /* ZRQINIT? */fnum==0, &startfile, &sent_bytes); else /* X/Ymodem */ success=xmodem_send_file(&xm, path, fp, &startfile, &sent_bytes); fclose(fp); if((t=time(NULL)-startfile)<=0) t=1; if((cps=sent_bytes/t)==0) cps=1; if(success) { xm.sent_files++; xm.sent_bytes+=fsize; lprintf(LOG_INFO,"Successful - Time: %lu:%02lu CPS: %lu" ,t/60,t%60,cps); if(xm.total_files-xm.sent_files) lprintf(LOG_INFO,"Remaining - Time: %lu:%02lu Files: %u KBytes: %lu" ,((xm.total_bytes-xm.sent_bytes)/cps)/60 ,((xm.total_bytes-xm.sent_bytes)/cps)%60 ,xm.total_files-xm.sent_files ,(xm.total_bytes-xm.sent_bytes)/1024 ); } else lprintf(LOG_WARNING,"File Transfer %s", aborted ? "Aborted" : "Failure"); /* DSZLOG entry */ if(logfp) { lprintf(LOG_DEBUG,"Updating DSZLOG: %s", dszlog); fprintf(logfp,"%c %7lu %5u bps %6lu cps %3u errors %5u %4u " "%s -1\n" ,success ? (mode&ZMODEM ? 'z':'S') : (mode&ZMODEM && zm.file_skipped) ? 's' : 'E' ,sent_bytes ,115200 /* baud */ ,cps ,mode&ZMODEM ? zm.errors : xm.errors ,flows ,mode&ZMODEM ? zm.block_size : xm.block_size ,dszlog_filename(path)); fflush(logfp); } total_bytes += sent_bytes; if(aborted) { xm.cancelled=FALSE; xmodem_cancel(&xm); break; } if(xm.cancelled || zm.cancelled) break; } /* while(gi<(int)g.gl_pathc) */ if(gi<(int)g.gl_pathc)/* error occurred */ break; } if(mode&ZMODEM && !zm.cancelled && is_connected(NULL)) zmodem_get_zfin(&zm); if(fnum<fnames) /* error occurred */ return(-1); if(!success) return(-1); if(mode&XMODEM) return(0); if(mode&YMODEM) { if(xmodem_get_mode(&xm)) { lprintf(LOG_INFO,"Sending Ymodem termination block"); memset(block,0,128); /* send short block for terminator */ xmodem_put_block(&xm, block, 128 /* block_size */, 0 /* block_num */); if(!xmodem_get_ack(&xm,6,0)) { lprintf(LOG_WARNING,"Failed to receive ACK after terminating block"); } } } if(xm.total_files>1) { t=time(NULL)-startall; if(!t) t=1; lprintf(LOG_INFO,"Overall - Time %02lu:%02lu KBytes: %lu CPS: %lu" ,t/60,t%60,total_bytes/1024,total_bytes/t); } return(0); /* success */ }
/* * Delete the results of a package installation. * * This is here rather than in the pkg_delete code because pkg_add needs to * run it too in cases of failure. */ int delete_package(Boolean ign_err, Boolean nukedirs, Package *pkg) { PackingList p; const char *Where = ".", *last_file = ""; Boolean fail = SUCCESS; Boolean preserve; char tmp[FILENAME_MAX], *name = NULL; char *prefix = NULL; preserve = find_plist_option(pkg, "preserve") ? TRUE : FALSE; for (p = pkg->head; p; p = p->next) { switch (p->type) { case PLIST_NAME: name = p->name; break; case PLIST_IGNORE: p = p->next; break; case PLIST_CWD: if (!prefix) prefix = p->name; Where = (p->name == NULL) ? prefix : p->name; if (Verbose) printf("Change working directory to %s\n", Where); break; case PLIST_UNEXEC: format_cmd(tmp, FILENAME_MAX, p->name, Where, last_file); if (Verbose) printf("Execute '%s'\n", tmp); if (!Fake && system(tmp)) { warnx("unexec command for '%s' failed", tmp); fail = FAIL; } break; case PLIST_FILE: last_file = p->name; if (*p->name == '/') strlcpy(tmp, p->name, FILENAME_MAX); else sprintf(tmp, "%s/%s", Where, p->name); if (isdir(tmp) && fexists(tmp) && !issymlink(tmp)) { warnx("cannot delete specified file '%s' - it is a directory!\n" "this packing list is incorrect - ignoring delete request", tmp); } else { if (p->next && p->next->type == PLIST_COMMENT && !strncmp(p->next->name, "MD5:", 4)) { char *cp = NULL, buf[33]; /* * For packing lists whose version is 1.1 or greater, the md5 * hash for a symlink is calculated on the string returned * by readlink(). */ if (issymlink(tmp) && verscmp(pkg, 1, 0) > 0) { int len; char linkbuf[FILENAME_MAX]; if ((len = readlink(tmp, linkbuf, FILENAME_MAX)) > 0) cp = MD5Data((unsigned char *)linkbuf, len, buf); } else if (isfile(tmp) || verscmp(pkg, 1, 1) < 0) cp = MD5File(tmp, buf); if (cp != NULL) { /* Mismatch? */ if (strcmp(cp, p->next->name + 4)) { warnx("'%s' fails original MD5 checksum - %s", tmp, Force ? "deleted anyway." : "not deleted."); if (!Force) { fail = FAIL; continue; } } } } if (Verbose) printf("Delete file %s\n", tmp); if (!Fake) { if (delete_hierarchy(tmp, ign_err, nukedirs)) fail = FAIL; if (preserve && name) { char tmp2[FILENAME_MAX]; if (make_preserve_name(tmp2, FILENAME_MAX, name, tmp)) { if (fexists(tmp2)) { if (rename(tmp2, tmp)) warn("preserve: unable to restore %s as %s", tmp2, tmp); } } } } } break; case PLIST_DIR_RM: sprintf(tmp, "%s/%s", Where, p->name); if (!isdir(tmp) && fexists(tmp)) { warnx("cannot delete specified directory '%s' - it is a file!\n" "this packing list is incorrect - ignoring delete request", tmp); } else { if (Verbose) printf("Delete directory %s\n", tmp); if (!Fake && delete_hierarchy(tmp, ign_err, FALSE)) { warnx("unable to completely remove directory '%s'", tmp); fail = FAIL; } } last_file = p->name; break; default: break; } } return fail; }
static int hg_probe(vccontext_t* context) { return isdir(".hg"); }
gint layout_set_path(LayoutWindow *lw, const gchar *path) { gint have_file = FALSE; if (!layout_valid(&lw)) return FALSE; if (!path || !isname(path)) return FALSE; if (lw->path && path && strcmp(path, lw->path) == 0) { return TRUE; } if (isdir(path)) { g_free(lw->path); lw->path = g_strdup(path); } else { gchar *base; base = remove_level_from_path(path); if (lw->path && strcmp(lw->path, base) == 0) { g_free(base); } else if (isdir(base)) { g_free(lw->path); lw->path = base; } else { g_free(base); return FALSE; } if (isfile(path)) have_file = TRUE; } if (lw->path_entry) tab_completion_append_to_history(lw->path_entry, lw->path); layout_sync_path(lw); if (have_file) { gint row; row = layout_list_get_index(lw, path); if (row >= 0) { layout_image_set_index(lw, row); } else { layout_image_set_path(lw, path); } } else if (!lazy_image_sync) { layout_image_set_index(lw, 0); } return TRUE; }
int vms_copy(char *vms1,char *vms2,COP_PARAM *cop_param) { int bFailIfExists = FALSE; int nError = 0; char dos1[MAX_TOKEN]; char dos2[MAX_TOKEN]; char vms0[MAX_TOKEN]; char directory1[_MAX_PATH]; char directory2[_MAX_PATH]; char drive1[_MAX_DRIVE]; char dir1[_MAX_DIR]; char file1[_MAX_FNAME]; char ext1[_MAX_EXT]; char drive2[_MAX_DRIVE]; char dir2[_MAX_DIR]; char file2[_MAX_FNAME]; char ext2[_MAX_EXT]; size_t i = 0; int retcod = DCL_OK; *dos1 = 0; *drive1 = 0; *dir1 = 0; *file1 = 0; *ext1 =0; *directory1 = 0; *dos2 = 0; *drive2 = 0; *dir2 = 0; *file2 = 0; *ext2 =0; *directory2 = 0; cvfs_vms_to_dos(vms1,dos1,(int *)&i); _splitpath(dos1,drive1,dir1,file1,ext1); cvfs_vms_to_dos(vms2,dos2,(int *)&i); if (isdir(dos2) && dos2[strlen(dos2)-1] != SLASH_CHR) strcat(dos2,SLASH_STR); if (dos1[strlen(dos1)-1] == SLASH_CHR) dos1[strlen(dos1)-1] = '\0'; if (!cvfs_check_device(dos2)) { _splitpath(dos2,drive2,dir2,file2,ext2); if (!*file2) strcpy(file2,file1); if (*file2 == '*') strcpy(file2,file1); if (!*ext2) strcpy(ext2,ext1); if (strncmp(ext2,".*",2)==0) strcpy(ext2,ext1); for (i = 0;i < strlen(file2); i++) if (file2[i] == '?') file2[i] = file1[i]; for (i = 0;i < strlen(ext2); i++) if (ext2[i] == '?') ext2[i] = ext1[i]; _makepath(dos2,drive2,dir2,file2,ext2); cvfs_dos_to_vms(dos2,vms2); if (cop_param->fnew) { if (filetstamp(dos1) <= filetstamp(dos2)) { goto exit_label; } } } _makepath(directory1,drive1,dir1,NULL,NULL); if (SUBDIR) { for(i = 1; i < strlen(dir1) && dir1[i] != SLASH_CHR; i++) ; if (dir1[i] == SLASH_CHR) i++; strcat(dir2, &dir1[i]); _makepath(dos2,drive2,dir2,file2,ext2); } _makepath(directory2,drive2,dir2,NULL,NULL); bFailIfExists = cop_param->replace ? FALSE : TRUE; (void)_mkdir(directory2); if (*file2) { nError = filecopy(dos1, dos2, bFailIfExists); } if (nError) { (void)dcl_printf(dcl[D].SYS_OUTPUT,"%s: %s\n",vms1,strerror(errno)); _STATUS = nError; _SEVERITY = 2; retcod = DCL_ERROR; } else { cop_param->file_copied++; if (cop_param->log) { cvfs_dos_to_vms(dos2,vms0); (void)dcl_printf(dcl[D].SYS_OUTPUT,"%s copied to %s.\n",vms1,vms0); } } exit_label: return(retcod); }
bool makedir(const char* dir) { if (isdir(dir)) return true; return mkdir(dir, 0755) == 0; }
static int svn_probe(vccontext_t *context) { return isdir(".svn"); }
/******************************************************************* * 根據 URLParaType 執行 GET 的要求 * * * return WebRespondType *******************************************************************/ int DoGetRequest(REQUEST_REC * rc, BOARDHEADER * board, POST_FILE * pf) { char *p, *boardname; int URLParaType = rc->URLParaType; char fname[PATHLEN]; boardname = board->filename; if (URLParaType == Redirect) { /* redirect target must set in ParseURI() */ return WEB_REDIRECT; } if (PSCorrect != Correct && (URLParaType == MailList || URLParaType == MailRead || URLParaType == SkinModify)) { return WEB_USER_NOT_LOGIN; } if (URLParaType == PostList || URLParaType == PostRead || URLParaType == TreaList || URLParaType == TreaRead || URLParaType == SkinModify || URLParaType == Board) { int perm; if (get_board(board, boardname) <= 0 || board->filename[0] == '\0') return WEB_BOARD_NOT_FOUND; if ((perm = CheckBoardPerm(board, &curuser)) != WEB_OK) return perm; if (board->brdtype & BRD_WEBSKIN) /* Board has custom html skin */ { char *skin, web_board_dir[PATHLEN]; if (URLParaType == SkinModify) { if (strlen(pf->POST_NAME) != 0) { xstrncpy(web_board_dir, pf->POST_NAME, PATHLEN); skin = strrchr(web_board_dir, '/') + 1; setskinfile(pf->POST_NAME, boardname, skin); } } else if (!strstr(skin_file->filename, HTML_BoardModify)) { /* set specfic skin file to custom file */ xstrncpy(web_board_dir, skin_file->filename, PATHLEN); skin = strrchr(web_board_dir, '/') + 1; setskinfile(skin_file->filename, boardname, skin); } } else { if (strstr(skin_file->filename, HTML_SkinModify)) return WEB_FILE_NOT_FOUND; } } if (strstr(skin_file->filename, HTML_BoardModify) && (!HAS_PERM(PERM_SYSOP) || PSCorrect != Correct)) { return WEB_FILE_NOT_FOUND; } switch (URLParaType) { case TreaRead: case PostRead: if (GetPostInfo(board, pf) != WEB_OK) return WEB_FILE_NOT_FOUND; break; case TreaList: case PostList: pf->total_rec = get_num_records(pf->POST_NAME, FH_SIZE); break; case MailList: if (PSCorrect == Correct) pf->total_rec = get_num_records(pf->POST_NAME, FH_SIZE); else pf->total_rec = 0; break; case MailRead: if (PSCorrect == Correct) { int RESULT = GetPostInfo(board, pf); if (RESULT != WEB_OK) return RESULT; } break; case UserList: case BoardList: case TreaBoardList: case UserData: case SkinModify: /* do nothing here.. */ break; case UserQuery: /* put USER_REC in curuser for query */ if (!get_passwd(&curuser, username)) { bzero(&curuser, sizeof(USEREC)); return WEB_USER_NOT_FOUND; } break; case Board: /* cuscom webboard */ case Mail: /* ?? */ #if 0 fprintf(fp_out, "DoGetRequest Board,Mail:[%s]", skin_file->filename); fflush(fp_out); #endif if (CacheState(skin_file->filename, NULL) < 0 && !isfile(skin_file->filename)) { return WEB_FILE_NOT_FOUND; } break; default: #if 0 fprintf(fp_out, "DoGetRequest default:[%s]\r\n", skin_file->filename); fflush(fp_out); #endif xstrncpy(fname, skin_file->filename, sizeof(fname)); if (isBadURI(fname)) { BBS_SUBDIR[0] = 0x00; return WEB_BAD_REQUEST; } sprintf(skin_file->filename, "%s%s", HTML_PATH, fname + 1); if (CacheState(skin_file->filename, NULL) == -1) /* file not in cache */ { if (isdir(skin_file->filename)) { p = skin_file->filename + strlen(skin_file->filename) - 1; if (*p == '/') { strcat(skin_file->filename, DEFAULT_HTML); } else { sprintf(skin_file->filename, "%s/", fname); return WEB_REDIRECT; } } else { if ((p = strrchr(fname + 1, '/')) == NULL) p = fname; if (!strcmp(p, "/boards") || !strcmp(p, "/treasure") || !strcmp(p, "/mail") || !strcmp(p, "/users")) { sprintf(skin_file->filename, "%s/", fname); return WEB_REDIRECT; } } if (!isfile(skin_file->filename)) { BBS_SUBDIR[0] = 0x00; return WEB_FILE_NOT_FOUND; } } #ifdef WEB_LOGIN_CHECK return WebLoginCheck(); #endif } return WEB_OK; }
/* search_for_exec_prefix requires that argv0_path be no more than MAXPATHLEN bytes long. */ static int search_for_exec_prefix(wchar_t *argv0_path, wchar_t *home, wchar_t *_exec_prefix) { size_t n; /* If PYTHONHOME is set, we believe it unconditionally */ if (home) { wchar_t *delim; delim = wcschr(home, DELIM); if (delim) wcsncpy(exec_prefix, delim+1, MAXPATHLEN); else wcsncpy(exec_prefix, home, MAXPATHLEN); joinpath(exec_prefix, lib_python); joinpath(exec_prefix, L"lib-dynload"); return 1; } /* Check to see if argv[0] is in the build directory. "pybuilddir.txt" is written by setup.py and contains the relative path to the location of shared library modules. */ wcscpy(exec_prefix, argv0_path); joinpath(exec_prefix, L"pybuilddir.txt"); if (isfile(exec_prefix)) { FILE *f = _Py_wfopen(exec_prefix, L"rb"); if (f == NULL) errno = 0; else { char buf[MAXPATHLEN+1]; PyObject *decoded; wchar_t rel_builddir_path[MAXPATHLEN+1]; n = fread(buf, 1, MAXPATHLEN, f); buf[n] = '\0'; fclose(f); decoded = PyUnicode_DecodeUTF8(buf, n, "surrogateescape"); if (decoded != NULL) { Py_ssize_t k; k = PyUnicode_AsWideChar(decoded, rel_builddir_path, MAXPATHLEN); Py_DECREF(decoded); if (k >= 0) { rel_builddir_path[k] = L'\0'; wcscpy(exec_prefix, argv0_path); joinpath(exec_prefix, rel_builddir_path); return -1; } } } } /* Search from argv0_path, until root is found */ copy_absolute(exec_prefix, argv0_path, MAXPATHLEN+1); do { n = wcslen(exec_prefix); joinpath(exec_prefix, lib_python); joinpath(exec_prefix, L"lib-dynload"); if (isdir(exec_prefix)) return 1; exec_prefix[n] = L'\0'; reduce(exec_prefix); } while (exec_prefix[0]); /* Look at configure's EXEC_PREFIX */ wcsncpy(exec_prefix, _exec_prefix, MAXPATHLEN); joinpath(exec_prefix, lib_python); joinpath(exec_prefix, L"lib-dynload"); if (isdir(exec_prefix)) return 1; /* Fail */ return 0; }
int f_put (char **vec) { int append; #ifdef BRIDGE int result; char *dst; #else int sglobbed; char *bp, *dst, **gp, **src; char *freedst = NULL, buffer[BUFSIZ]; #endif append = strcmp (*vec, "append") == 0; if (*++vec == NULL) { #ifdef BRIDGE return NOTOK; #else if (getftamline ("source: ", buffer) == NOTOK || str2vec (buffer, vec) < 1) return OK; dst = NULL; #endif } else { #ifdef BRIDGE dst = *vec; #else char **ap; for (ap = vec; *ap; ap++) continue; if (--ap != vec) dst = *ap, *ap = NULL; else dst = NULL; #endif } #ifndef BRIDGE if (!(src = xglob (vec, 0))) return OK; sglobbed = xglobbed; if (dst == NULL) { if (getftamline ("destination: ", buffer) == NOTOK) { blkfree (src); return OK; } switch (str2vec (buffer, vec)) { case 0: break; case 1: dst = *vec; break; default: advise (NULLCP, "too many destinations"); goto out; } } if (dst && !(dst = freedst = xglob1val (dst, 0))) goto out; if (src[1] == NULL) { if (interrupted) goto out; if (dst == NULL) { switch (realstore) { case RFS_UNIX: if (dst = rindex (*src, '/')) dst++; if (dst == NULL || *dst == NULL) dst = *src; break; default: dst = *src; break; } dst = str2file (dst); ask_it: ; if (query) switch (ask ("%s %s %s", append ? "append" : "put", *src, dst)) { case NOTOK: goto out; case OK: default: break; case DONE: goto out; } } else switch (realstore) { case RFS_UNIX: if (isdir (dst, NULLCP, 1) == NOTOK) break; #ifdef apollo if (*dst == '/') sprintf (bp = buffer, "%s", dst); else #endif sprintf (bp = buffer, "%s/", dst); bp += strlen (bp); if (dst = rindex (*src, '/')) dst++; if (dst == NULL || *dst == NULL) dst = *src; strcpy (bp, dst); dst = buffer; goto ask_it; default: break; } dst = str2file (dst); put (*src, dst, append); goto out; } switch (realstore) { case RFS_UNKNOWN: advise (NULLCP, "%s", rs_unknown); goto out; case RFS_UNIX: if (dst) #ifdef apollo if (*(bp = str2file (dst)) == '/') { strcpy (buffer, bp); bp = buffer; } else #endif sprintf (bp = buffer, "%s/", str2file (dst)); else if (rcwd) sprintf (bp = buffer, "%s", str2file ("")); else strcpy (bp = buffer, "./"); bp += strlen (bp); break; default: advise (NULLCP, "%s", rs_support); goto out; } if (isdir (str2file (buffer), NULLCP, 0) == NOTOK) goto out; for (gp = src; *gp && !interrupted; gp++) { switch (realstore) { case RFS_UNIX: if (dst = rindex (*gp, '/')) dst++; if (dst == NULL || *dst == NULL) dst = *gp; break; default: dst = *gp; break; } strcpy (bp, dst); dst = str2file (buffer); if (sglobbed) { if (query) switch (ask ("%s %s %s", append ? "append" : "put", *gp, dst)) { case NOTOK: continue; case OK: default: break; case DONE: goto out; } else advise (NULLCP, "%s %s %s", append ? "append" : "put", *gp, dst); } put (*gp, dst, append); if (ftamfd == NOTOK) break; } out: ; blkfree (src); if (freedst) free (freedst); return OK; #else result = put (dst, append); return result; #endif }
ReturnStatus FileMetaDAO::movDir(const std::string &srcPath, const std::string &destPath) { Channel* pDataChannel = ChannelManager::getInstance()->Mapping(m_BucketId); NameSpace *DataNS = pDataChannel->m_DataNS; int rt = 0; int error = 0; ReturnStatus rs; // check src path rs = isdir(srcPath); if (!rs.success()) { if (NOT_DIRECTORY == rs.errorCode) { return ReturnStatus(MU_FAILED, SRC_PATH_NOT_DIRECTORY); } else if (PATH_INVALID == rs.errorCode) { return ReturnStatus(MU_FAILED, SRC_PATH_INVALID); } else if (PATH_NOT_EXIST == rs.errorCode) { return ReturnStatus(MU_FAILED, SRC_PATH_NOT_EXIST); } return rs; } // check dest path rs = isdir(prefix(destPath)); if (!rs.success()) { if (MU_UNKNOWN_ERROR != rs.errorCode) { return ReturnStatus(MU_FAILED, DEST_PATH_INVALID); } return rs; } rt = DataNS->Move(srcPath.c_str(), destPath.c_str()); if (-1 == rt) { error = errno; ERROR_LOG("src path %s, dest path %s, rename() error, %s.", srcPath.c_str(), destPath.c_str(), strerror(error)); if (ENOTDIR == error) { return ReturnStatus(MU_FAILED, NOT_DIRECTORY); } else if (ENOTEMPTY == error || EEXIST == error) { return ReturnStatus(MU_FAILED, DIRECTORY_NOT_EMPTY); } else { return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR); } } return ReturnStatus(MU_SUCCESS); }
/* search_for_exec_prefix requires that argv0_path be no more than MAXPATHLEN bytes long. */ static int search_for_exec_prefix(char *argv0_path, char *home) { size_t n; /* If PYTHONHOME is set, we believe it unconditionally */ if (home) { char *delim; delim = strchr(home, DELIM); if (delim) strncpy(exec_prefix, delim+1, MAXPATHLEN); else strncpy(exec_prefix, home, MAXPATHLEN); joinpath(exec_prefix, lib_python); joinpath(exec_prefix, "lib-dynload"); return 1; } /* Check to see if argv[0] is in the build directory. "pybuilddir.txt" is written by setup.py and contains the relative path to the location of shared library modules. */ strcpy(exec_prefix, argv0_path); joinpath(exec_prefix, "pybuilddir.txt"); if (isfile(exec_prefix)) { FILE *f = fopen(exec_prefix, "r"); if (f == NULL) errno = 0; else { char rel_builddir_path[MAXPATHLEN+1]; size_t n; n = fread(rel_builddir_path, 1, MAXPATHLEN, f); rel_builddir_path[n] = '\0'; fclose(f); if (n >= 0) { strcpy(exec_prefix, argv0_path); joinpath(exec_prefix, rel_builddir_path); return -1; } } } /* Search from argv0_path, until root is found */ copy_absolute(exec_prefix, argv0_path); do { n = strlen(exec_prefix); joinpath(exec_prefix, lib_python); joinpath(exec_prefix, "lib-dynload"); if (isdir(exec_prefix)) return 1; exec_prefix[n] = '\0'; reduce(exec_prefix); } while (exec_prefix[0]); /* Look at configure's EXEC_PREFIX */ strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN); joinpath(exec_prefix, lib_python); joinpath(exec_prefix, "lib-dynload"); if (isdir(exec_prefix)) return 1; /* Fail */ return 0; }
FILE * collect(struct header *hp, int printheaders) { FILE *fbuf; int lc, cc, fd, c, t, lastlong, rc, sig; int escape, eofcount, longline; char getsub; char linebuf[LINESIZE], tempname[PATHSIZE], *cp; collf = NULL; eofcount = 0; hadintr = 0; lastlong = 0; longline = 0; if ((cp = value("escape")) != NULL) escape = *cp; else escape = ESCAPE; noreset++; (void)snprintf(tempname, sizeof(tempname), "%s/mail.RsXXXXXXXXXX", tmpdir); if ((fd = mkstemp(tempname)) == -1 || (collf = Fdopen(fd, "w+")) == NULL) { warn("%s", tempname); goto err; } (void)rm(tempname); /* * If we are going to prompt for a subject, * refrain from printing a newline after * the headers (since some people mind). */ t = GTO|GSUBJECT|GCC|GNL; getsub = 0; if (hp->h_subject == NULL && value("interactive") != NULL && (value("ask") != NULL || value("asksub") != NULL)) t &= ~GNL, getsub++; if (printheaders) { puthead(hp, stdout, t); fflush(stdout); } if (getsub && gethfromtty(hp, GSUBJECT) == -1) goto err; if (0) { cont: /* Come here for printing the after-suspend message. */ if (isatty(0)) { puts("(continue)"); fflush(stdout); } } for (;;) { c = readline(stdin, linebuf, LINESIZE, &sig); /* Act on any signal caught during readline() ignoring 'c' */ switch (sig) { case 0: break; case SIGINT: if (collabort()) goto err; continue; case SIGHUP: rewind(collf); savedeadletter(collf); /* * Let's pretend nobody else wants to clean up, * a true statement at this time. */ exit(1); default: /* Stopped due to job control */ (void)kill(0, sig); goto cont; } /* No signal, check for error */ if (c < 0) { if (value("interactive") != NULL && value("ignoreeof") != NULL && ++eofcount < 25) { puts("Use \".\" to terminate letter"); continue; } break; } lastlong = longline; longline = (c == LINESIZE - 1); eofcount = 0; hadintr = 0; if (linebuf[0] == '.' && linebuf[1] == '\0' && value("interactive") != NULL && !lastlong && (value("dot") != NULL || value("ignoreeof") != NULL)) break; if (linebuf[0] != escape || value("interactive") == NULL || lastlong) { if (putline(collf, linebuf, !longline) < 0) goto err; continue; } c = linebuf[1]; switch (c) { default: /* * On double escape, just send the single one. * Otherwise, it's an error. */ if (c == escape) { if (putline(collf, &linebuf[1], !longline) < 0) goto err; else break; } puts("Unknown tilde escape."); break; case '!': /* * Shell escape, send the balance of the * line to sh -c. */ shell(&linebuf[2]); break; case ':': case '_': /* * Escape to command mode, but be nice! */ execute(&linebuf[2], 1); goto cont; case '.': /* * Simulate end of file on input. */ goto out; case 'q': /* * Force a quit of sending mail. * Act like an interrupt happened. */ hadintr++; collabort(); fputs("Interrupt\n", stderr); goto err; case 'x': /* * Force a quit of sending mail. * Do not save the message. */ goto err; case 'h': /* * Grab a bunch of headers. */ grabh(hp, GTO|GSUBJECT|GCC|GBCC); goto cont; case 't': /* * Add to the To list. */ hp->h_to = cat(hp->h_to, extract(&linebuf[2], GTO)); break; case 's': /* * Set the Subject list. */ cp = &linebuf[2]; while (isspace(*cp)) cp++; hp->h_subject = savestr(cp); break; case 'c': /* * Add to the CC list. */ hp->h_cc = cat(hp->h_cc, extract(&linebuf[2], GCC)); break; case 'b': /* * Add stuff to blind carbon copies list. */ hp->h_bcc = cat(hp->h_bcc, extract(&linebuf[2], GBCC)); break; case 'd': linebuf[2] = '\0'; strlcat(linebuf, getdeadletter(), sizeof(linebuf)); /* fall into . . . */ case 'r': case '<': /* * Invoke a file: * Search for the file name, * then open it and copy the contents to collf. */ cp = &linebuf[2]; while (isspace(*cp)) cp++; if (*cp == '\0') { puts("Interpolate what file?"); break; } cp = expand(cp); if (cp == NULL) break; if (isdir(cp)) { printf("%s: Directory\n", cp); break; } if ((fbuf = Fopen(cp, "r")) == NULL) { warn("%s", cp); break; } printf("\"%s\" ", cp); fflush(stdout); lc = 0; cc = 0; while ((rc = readline(fbuf, linebuf, LINESIZE, NULL)) >= 0) { if (rc != LINESIZE - 1) lc++; if ((t = putline(collf, linebuf, rc != LINESIZE-1)) < 0) { (void)Fclose(fbuf); goto err; } cc += t; } (void)Fclose(fbuf); printf("%d/%d\n", lc, cc); break; case 'w': /* * Write the message on a file. */ cp = &linebuf[2]; while (*cp == ' ' || *cp == '\t') cp++; if (*cp == '\0') { fputs("Write what file!?\n", stderr); break; } if ((cp = expand(cp)) == NULL) break; rewind(collf); exwrite(cp, collf, 1); break; case 'm': case 'M': case 'f': case 'F': /* * Interpolate the named messages, if we * are in receiving mail mode. Does the * standard list processing garbage. * If ~f is given, we don't shift over. */ if (forward(linebuf + 2, collf, tempname, c) < 0) goto err; goto cont; case '?': if ((fbuf = Fopen(_PATH_TILDE, "r")) == NULL) { warn(_PATH_TILDE); break; } while ((t = getc(fbuf)) != EOF) (void)putchar(t); (void)Fclose(fbuf); break; case 'p': /* * Print out the current state of the * message without altering anything. */ rewind(collf); puts("-------\nMessage contains:"); puthead(hp, stdout, GTO|GSUBJECT|GCC|GBCC|GNL); while ((t = getc(collf)) != EOF) (void)putchar(t); goto cont; case '|': /* * Pipe message through command. * Collect output as new message. */ rewind(collf); mespipe(collf, &linebuf[2]); goto cont; case 'v': case 'e': /* * Edit the current message. * 'e' means to use EDITOR * 'v' means to use VISUAL */ rewind(collf); mesedit(collf, c); goto cont; } } if (value("interactive") != NULL) { if (value("askcc") != NULL || value("askbcc") != NULL) { if (value("askcc") != NULL) { if (gethfromtty(hp, GCC) == -1) goto err; } if (value("askbcc") != NULL) { if (gethfromtty(hp, GBCC) == -1) goto err; } } else { puts("EOT"); (void)fflush(stdout); } } goto out; err: if (collf != NULL) { (void)Fclose(collf); collf = NULL; } out: if (collf != NULL) rewind(collf); noreset--; return(collf); }
Walkqid* devwalk(Chan *c, Chan *nc, char **name, int nname, Dirtab *tab, int ntab, Devgen *gen) { int i, j, alloc; Walkqid *wq; char *n; Dir dir; if(nname > 0) isdir(c); alloc = 0; wq = smalloc(sizeof(Walkqid)+(nname-1)*sizeof(Qid)); if(waserror()){ if(alloc && wq->clone!=nil) cclose(wq->clone); free(wq); return nil; } if(nc == nil){ nc = devclone(c); nc->type = 0; /* device doesn't know about this channel yet */ alloc = 1; } wq->clone = nc; for(j=0; j<nname; j++){ if(!(nc->qid.type&QTDIR)){ if(j==0) error(Enotdir); goto Done; } n = name[j]; if(strcmp(n, ".") == 0){ Accept: wq->qid[wq->nqid++] = nc->qid; continue; } if(strcmp(n, "..") == 0){ if((*gen)(nc, nil, tab, ntab, DEVDOTDOT, &dir) != 1){ print("devgen walk .. in dev%s %llux broken\n", devtab[nc->type]->name, nc->qid.path); error("broken devgen"); } nc->qid = dir.qid; goto Accept; } /* * Ugly problem: If we're using devgen, make sure we're * walking the directory itself, represented by the first * entry in the table, and not trying to step into a sub- * directory of the table, e.g. /net/net. Devgen itself * should take care of the problem, but it doesn't have * the necessary information (that we're doing a walk). */ if(gen==devgen && nc->qid.path!=tab[0].qid.path) goto Notfound; for(i=0;; i++) { switch((*gen)(nc, n, tab, ntab, i, &dir)){ case -1: Notfound: if(j == 0) error(Enonexist); kstrcpy(up->errstr, Enonexist, ERRMAX); goto Done; case 0: continue; case 1: if(strcmp(n, dir.name) == 0){ nc->qid = dir.qid; goto Accept; } continue; } } } /* * We processed at least one name, so will return some data. * If we didn't process all nname entries succesfully, we drop * the cloned channel and return just the Qids of the walks. */ Done: poperror(); if(wq->nqid < nname){ if(alloc) cclose(wq->clone); wq->clone = nil; }else if(wq->clone){ /* attach cloned channel to same device */ wq->clone->type = c->type; } return wq; }
// setup sets up the tree for the initial build. static void setup(void) { int i; Buf b; char *p; binit(&b); // Create bin directory. p = bpathf(&b, "%s/bin", goroot); if(!isdir(p)) xmkdir(p); // Create package directory. p = bpathf(&b, "%s/pkg", goroot); if(!isdir(p)) xmkdir(p); p = bpathf(&b, "%s/pkg/%s_%s", goroot, gohostos, gohostarch); if(rebuildall) xremoveall(p); xmkdirall(p); if(!streq(goos, gohostos) || !streq(goarch, gohostarch)) { p = bpathf(&b, "%s/pkg/%s_%s", goroot, goos, goarch); if(rebuildall) xremoveall(p); xmkdirall(p); } // Create object directory. // We keep it in pkg/ so that all the generated binaries // are in one tree. If pkg/obj/libgc.a exists, it is a dreg from // before we used subdirectories of obj. Delete all of obj // to clean up. bpathf(&b, "%s/pkg/obj/libgc.a", goroot); if(isfile(bstr(&b))) xremoveall(bpathf(&b, "%s/pkg/obj", goroot)); p = bpathf(&b, "%s/pkg/obj/%s_%s", goroot, gohostos, gohostarch); if(rebuildall) xremoveall(p); xmkdirall(p); // Create tool directory. // We keep it in pkg/, just like the object directory above. if(rebuildall) xremoveall(tooldir); xmkdirall(tooldir); // Remove tool binaries from before the tool/gohostos_gohostarch xremoveall(bpathf(&b, "%s/bin/tool", goroot)); // Remove old pre-tool binaries. for(i=0; i<nelem(oldtool); i++) xremove(bpathf(&b, "%s/bin/%s", goroot, oldtool[i])); // If $GOBIN is set and has a Go compiler, it must be cleaned. for(i=0; gochars[i]; i++) { if(isfile(bprintf(&b, "%s%s%c%s", gobin, slash, gochars[i], "g"))) { for(i=0; i<nelem(oldtool); i++) xremove(bprintf(&b, "%s%s%s", gobin, slash, oldtool[i])); break; } } // For release, make sure excluded things are excluded. if(hasprefix(goversion, "release.") || hasprefix(goversion, "go")) { for(i=0; i<nelem(unreleased); i++) if(isdir(bpathf(&b, "%s/%s", goroot, unreleased[i]))) fatal("%s should not exist in release build", bstr(&b)); } bfree(&b); }
/* * Name: averify * Description: This function verifies and (if fix > 0) fixes the attributes * of the file at the path provided. * Arguments: fix - 0 - do not fix entries, 1 - fix entries * ftype - single character "type" the entry is supposed to be * path - path to file * ainfo - attribute info structure representing the attributes * the entry is supposed to be * NOTE: attributes are links and permissions * Possible return values: * - 0 = successful * - VE_EXIST = path name does not exist * - VE_FTYPE = path file type is not recognized, is not supported, * or is not what was expected * - VE_ATTR = path mode/group/user is not what was expected * - VE_CONT = mod time/link target/major/minor/size/file system type/current * directory is not what was expected * - VE_FAIL = utime/target directory/link/stat/symlink/mknod/chmod/statvfs/ * chown failed */ int averify(int fix, char *ftype, char *path, struct ainfo *ainfo) { struct group *grp; /* group entry buffer */ struct passwd *pwd; int n; int setval; int uid, gid; int dochown; int retcode; int statError = 0; int targ_is_dir = 0; /* replacing a directory */ char myftype; char buf[PATH_MAX]; ino_t my_ino; dev_t my_dev; char cwd[MAXPATHLEN]; char *cd; char *c; setval = (*ftype == '?'); retcode = 0; reperr(NULL); if (get_disable_attribute_check()) { return (0); } if (*ftype == 'l') { if (stat(path, &status) < 0) { retcode = VE_EXIST; reperr(pkg_gt(ERR_EXIST)); } my_ino = status.st_ino; my_dev = status.st_dev; /* Get copy of the current working directory */ if (getcwd(cwd, MAXPATHLEN) == NULL) { reperr(pkg_gt(ERR_GETWD)); return (VE_FAIL); } /* * Change to the directory in which the hard * link is to be created. */ cd = strdup(path); c = strrchr(cd, '/'); if (c) { /* bugid 4247895 */ if (strcmp(cd, c) == 0) (void) strcpy(cd, "/"); else *c = NULL; if (chdir(cd) != 0) { reperr(pkg_gt(ERR_CHDIR), cd); return (VE_FAIL); } } free(cd); if (retcode || (status.st_nlink < 2) || (stat(ainfo->local, &status) < 0) || (my_dev != status.st_dev) || (my_ino != status.st_ino)) { if (fix) { /* * Don't want to do a hard link to a * directory. */ if (!isdir(ainfo->local)) { (void) chdir(cwd); reperr(pkg_gt(ERR_LINKISDIR), ainfo->local); return (VE_FAIL); } /* Now do the link. */ if (!clear_target(path, ftype, targ_is_dir)) return (VE_FAIL); if (link(ainfo->local, path)) { (void) chdir(cwd); reperr(pkg_gt(ERR_LINKFAIL), ainfo->local); return (VE_FAIL); } retcode = 0; } else { /* Go back to previous working directory */ if (chdir(cwd) != 0) reperr(pkg_gt(ERR_CHDIR), cwd); reperr(pkg_gt(ERR_LINK), ainfo->local); return (VE_CONT); } } /* Go back to previous working directory */ if (chdir(cwd) != 0) { reperr(pkg_gt(ERR_CHDIR), cwd); return (VE_CONT); } return (retcode); } retcode = 0; /* If we are to process symlinks the old way then we follow the link */ if (nonABI_symlinks()) { if ((*ftype == 's') ? lstat(path, &status) : stat(path, &status)) { reperr(pkg_gt(ERR_EXIST)); retcode = VE_EXIST; myftype = '?'; statError++; } /* If not then we inspect the target of the link */ } else { if ((n = lstat(path, &status)) == -1) { reperr(pkg_gt(ERR_EXIST)); retcode = VE_EXIST; myftype = '?'; statError++; } } if (!statError) { /* determining actual type of existing object */ switch (status.st_mode & S_IFMT) { case S_IFLNK: myftype = 's'; break; case S_IFIFO: myftype = 'p'; break; case S_IFCHR: myftype = 'c'; break; case S_IFDIR: myftype = 'd'; targ_is_dir = 1; break; case S_IFBLK: myftype = 'b'; break; case S_IFREG: case 0: myftype = 'f'; break; case S_IFDOOR: myftype = 'D'; break; default: reperr(pkg_gt(ERR_UNKNOWN)); return (VE_FTYPE); } } if (setval) { /* * Check to make sure that a package or an installf that uses * wild cards '?' to assume the ftype of an object on the * system is not assuming a door ftype. Doors are not supported * but should be ignored. */ if (myftype == 'D') { reperr(pkg_gt(ERR_FTYPED), path); retcode = VE_FTYPE; return (VE_FTYPE); } else { *ftype = myftype; } } else if (!retcode && (*ftype != myftype) && ((myftype != 'f') || !strchr("ilev", *ftype)) && ((myftype != 'd') || (*ftype != 'x'))) { reperr(pkg_gt(ERR_FTYPE), *ftype, myftype); retcode = VE_FTYPE; } if (!retcode && (*ftype == 's')) { /* make sure that symbolic link is correct */ n = readlink(path, buf, PATH_MAX); if (n < 0) { reperr(pkg_gt(ERR_SLINK), ainfo->local); retcode = VE_CONT; } else if (ainfo->local != NULL) { buf[n] = '\0'; if (strcmp(buf, ainfo->local)) { reperr(pkg_gt(ERR_SLINK), ainfo->local); retcode = VE_CONT; } } else if (ainfo->local == NULL) { /* * Since a sym link target exists, insert it * into the ainfo structure */ buf[n] = '\0'; ainfo->local = strdup(buf); } } if (retcode) { /* The path doesn't exist or is different than it should be. */ if (fix) { /* * Clear the way for the write. If it won't clear, * there's nothing we can do. */ if (!clear_target(path, ftype, targ_is_dir)) return (VE_FAIL); if ((*ftype == 'd') || (*ftype == 'x')) { char *pt, *p; /* Try to make it the easy way */ if (mkdir(path, ainfo->mode)) { /* * Failing that, walk through the * parent directories creating * whatever is needed. */ p = strdup(path); pt = (*p == '/') ? p+1 : p; do { if (pt = strchr(pt, '/')) *pt = '\0'; if (access(p, 0) && mkdir(p, ainfo->mode)) break; if (pt) *pt++ = '/'; } while (pt); free(p); } if (stat(path, &status) < 0) { reperr(pkg_gt(ERR_DIRFAIL)); return (VE_FAIL); } } else if (*ftype == 's') { if (symlink(ainfo->local, path)) { reperr(pkg_gt(ERR_SLINKFAIL), ainfo->local); return (VE_FAIL); } } else if (*ftype == 'c') { int wilddevno = 0; /* * The next three if's support 2.4 and older * packages that use "?" as device numbers. * This should be considered for removal by * release 2.7 or so. */ if (ainfo->major == BADMAJOR) { ainfo->major = 0; wilddevno = 1; } if (ainfo->minor == BADMINOR) { ainfo->minor = 0; wilddevno = 1; } if (wilddevno) { wilddevno = 0; logerr(MSG_WLDDEVNO, path, ainfo->major, ainfo->minor); } if (mknod(path, ainfo->mode | S_IFCHR, makedev(ainfo->major, ainfo->minor)) || (stat(path, &status) < 0)) { reperr(pkg_gt(ERR_CDEVFAIL)); return (VE_FAIL); } } else if (*ftype == 'b') { int wilddevno = 0; /* * The next three if's support 2.4 and older * packages that use "?" as device numbers. * This should be considered for removal by * release 2.7 or so. */ if (ainfo->major == BADMAJOR) { ainfo->major = 0; wilddevno = 1; } if (ainfo->minor == BADMINOR) { ainfo->minor = 0; wilddevno = 1; } if (wilddevno) { wilddevno = 0; logerr(MSG_WLDDEVNO, path, ainfo->major, ainfo->minor); } if (mknod(path, ainfo->mode | S_IFBLK, makedev(ainfo->major, ainfo->minor)) || (stat(path, &status) < 0)) { reperr(pkg_gt(ERR_BDEVFAIL)); return (VE_FAIL); } } else if (*ftype == 'p') { if (mknod(path, ainfo->mode | S_IFIFO, NULL) || (stat(path, &status) < 0)) { reperr(pkg_gt(ERR_PIPEFAIL)); return (VE_FAIL); } } else return (retcode); } else return (retcode); } if (*ftype == 's') return (0); /* don't check anything else */ if (*ftype == 'i') return (0); /* don't check anything else */ retcode = 0; if ((myftype == 'c') || (myftype == 'b')) { if (setval || (ainfo->major == BADMAJOR)) ainfo->major = major(status.st_rdev); if (setval || (ainfo->minor == BADMINOR)) ainfo->minor = minor(status.st_rdev); /* check major & minor */ if (status.st_rdev != makedev(ainfo->major, ainfo->minor)) { reperr(pkg_gt(ERR_MAJMIN), ainfo->major, ainfo->minor, major(status.st_rdev), minor(status.st_rdev)); retcode = VE_CONT; } } /* compare specified mode w/ actual mode excluding sticky bit */ if (setval || (ainfo->mode == BADMODE) || (ainfo->mode == WILDCARD)) ainfo->mode = status.st_mode & 07777; else if ((ainfo->mode & 06777) != (status.st_mode & 06777)) { if (fix) { if ((ainfo->mode == BADMODE) || (chmod(path, ainfo->mode) < 0)) retcode = VE_FAIL; } else { reperr(pkg_gt(ERR_PERM), ainfo->mode, status.st_mode & 07777); if (!retcode) retcode = VE_ATTR; } } dochown = 0; /* get group entry for specified group */ if (setval || strcmp(ainfo->group, BADGROUP) == 0) { grp = cgrgid(status.st_gid); if (grp) (void) strcpy(ainfo->group, grp->gr_name); else { if (!retcode) retcode = VE_ATTR; reperr(pkg_gt(ERR_BADGRPID), status.st_gid); } gid = status.st_gid; } else if ((grp = cgrnam(ainfo->group)) == NULL) { reperr(pkg_gt(ERR_BADGRPNM), ainfo->group); if (!retcode) retcode = VE_ATTR; } else if ((gid = grp->gr_gid) != status.st_gid) { if (fix) { /* save specified GID */ gid = grp->gr_gid; dochown++; } else { if ((grp = cgrgid((int)status.st_gid)) == (struct group *)NULL) { reperr(pkg_gt(ERR_GROUP), ainfo->group, "(null)"); } else { reperr(pkg_gt(ERR_GROUP), ainfo->group, grp->gr_name); } if (!retcode) retcode = VE_ATTR; } } /* get password entry for specified owner */ if (setval || strcmp(ainfo->owner, BADOWNER) == 0) { pwd = cpwuid((int)status.st_uid); if (pwd) (void) strcpy(ainfo->owner, pwd->pw_name); else { if (!retcode) retcode = VE_ATTR; reperr(pkg_gt(ERR_BADUSRID), status.st_uid); } uid = status.st_uid; } else if ((pwd = cpwnam(ainfo->owner)) == NULL) { /* UID does not exist in password file */ reperr(pkg_gt(ERR_BADUSRNM), ainfo->owner); if (!retcode) retcode = VE_ATTR; } else if ((uid = pwd->pw_uid) != status.st_uid) { /* get owner name for actual UID */ if (fix) { uid = pwd->pw_uid; dochown++; } else { pwd = cpwuid((int)status.st_uid); if (pwd == NULL) reperr(pkg_gt(ERR_BADUSRID), (int)status.st_uid); else reperr(pkg_gt(ERR_OWNER), ainfo->owner, pwd->pw_name); if (!retcode) retcode = VE_ATTR; } } if (statvfs(path, &vfsstatus) < 0) { reperr(pkg_gt(ERR_EXIST)); retcode = VE_FAIL; } else { if (dochown) { /* pcfs doesn't support file ownership */ if (strcmp(vfsstatus.f_basetype, "pcfs") != 0 && chown(path, uid, gid) < 0) { retcode = VE_FAIL; /* chown failed */ } } } if (retcode == VE_FAIL) reperr(pkg_gt(ERR_ATTRFAIL)); return (retcode); }
static int rootgen(struct chan *c, char *name, struct dirtab *tab, int nd, int s, struct dir *dp) { int p, i; struct rootdata *r; int iter; printd("rootgen, path is %d, tap %p, nd %d s %d name %s\n", c->qid.path, tab, nd, s, name); if (s == DEVDOTDOT) { panic("this is busted"); p = rootdata[c->qid.path].dotdot; // XXX we need to set the vers too. equiv to mkqid(&c->qid, ...) c->qid.path = p; c->qid.type = QTDIR; name = devname(); if (p != 0) { /* TODO: what is this doing? do we want to walk the entire table, * or are we just walking the siblings of our parent? */ for (i = p;;) { if (roottab[i].qid.path == c->qid.path) { name = roottab[i].name; break; } i = roottab[i].qid.vers; if (!i) break; } } devdir(c, c->qid, name, 0, eve, 0777, dp); return 1; } if (c->qid.type != QTDIR) { /* return ourselved the first time; after that, -1 */ if (s) return -1; tab = &roottab[c->qid.path]; devdir(c, tab->qid, tab->name, tab->length, eve, tab->perm, dp); return 1; } if (name != NULL) { int path = c->qid.path; isdir(c); tab = &roottab[rootdata[path].child]; /* we're starting at a directory. It might be '.' */ for (iter = 0, i = rootdata[path].child; /* break */; iter++) { if (strncmp(tab->name, name, KNAMELEN) == 0) { printd("Rootgen returns 1 for %s\n", name); devdir(c, tab->qid, tab->name, tab->length, eve, tab->perm, dp); printd("return 1 with [%d, %d, %d]\n", dp->qid.path, dp->qid.vers, dp->qid.type); return 1; } if (iter > rootmaxq) { printk("BUG:"); dumprootdev(); printk("name %s\n", name); return -1; } i = roottab[i].qid.vers; if (!i) break; tab = &roottab[i]; } printd("rootgen: :%s: failed at path %d\n", name, path); return -1; } /* need to gen the file or the contents of the directory we are currently * at. but i think the tab entries are all over the place. nd is how * many entries the directory has. */ if (s >= nd) { printd("S OVERFLOW\n"); return -1; } //tab += s; /* this would only work if our entries were contig in the tab */ for (i = rootdata[c->qid.path].child; i; i = roottab[i].qid.vers) { tab = &roottab[i]; if (s-- == 0) break; } if (!i) { printd("I OVERFLOW\n"); return -1; } printd("root scan find returns path %p name %s\n", tab->qid.path, tab->name); devdir(c, tab->qid, tab->name, tab->length, eve, tab->perm, dp); return 1; }
/*--------------------------------------------------------------------------*/ void Initialize(void) { static char env[1024]; static char initstr[]="exec(\"SCI/etc/scilab.start\",-1);quit;"; static int iflag = -1, stacksize = 1000000, ierr = 0; #ifdef _MSC_VER #define nb_args 3 static char *argv[nb_args]; static char JavaSciInterf[]="javasci"; static char nw[]="-nw"; static char nb[]="-nb"; #endif char *sciPath = (char*)getenv("SCI"); #ifdef _MSC_VER /* Delete the windows mode and the banner */ { argv[0] = JavaSciInterf; argv[1] = nw; argv[2] = nb; setCommandLineArgs(argv, nb_args); } #endif #ifdef _MSC_VER if ( sciPath == NULL ) { /* Detection Scilab path */ char modname[PATH_MAX+1]; if (!GetModuleFileName (GetModuleHandle("javasci.dll"), modname, PATH_MAX)) { MessageBox(NULL,"javasci.dll not found","Warning",MB_ICONWARNING); } else { char *p = NULL; if ((p = strrchr (modname, '\\')) == NULL) exit(1); /* remove \javasci.dll from modname */ else { *p='\0'; if ((p = strrchr (modname, '\\')) == NULL) exit(1); /* remove \bin from modname */ else { *p='\0'; SetScilabEnvironmentVariables(modname); } } } } else { char *pathSCI = strdup(sciPath); SetScilabEnvironmentVariables(pathSCI); if (pathSCI) { FREE(pathSCI); pathSCI =NULL; } } #else if (sciPath==NULL) { fprintf(stderr,"Please define SCI environment variable\n"); exit(EXIT_FAILURE); } else { sprintf (env, "%s=%s", "SCI", sciPath); setSCIpath(SCI); putenv (env); } /* * This stuff is a workaround when the user is using javasci in the Scilab * official binary * The problem in this case is that the TCL_LIBRARY & TK_LIBRARY are not * set correctly and TCL has trouble to find himself. * * As we are sure to use the binary, we know where to find * See: http://bugzilla.scilab.org/show_bug.cgi?id=3605 */ #ifndef _MSC_VER #ifdef WITH_TK #define BASEPATHTOTHIRDPARTY "/../../thirdparty/" #define DIRECTORYOFTCL "tcl" #define DIRECTORYOFTK "tk" int commonPart=strlen(sciPath)+strlen(BASEPATHTOTHIRDPARTY)+strlen(".")+strlen(TCL_VERSION)+1; char *pathToTcl=(char*)MALLOC((strlen(DIRECTORYOFTCL)+commonPart)*sizeof(char)); sprintf(pathToTcl, "%s%s%s%s", sciPath, BASEPATHTOTHIRDPARTY, DIRECTORYOFTCL, TCL_VERSION); /* Test if we find the thirdparty directory. If it is the case, it is most * probable that we are working with the binary version of Scilab */ if (isdir(pathToTcl)){ #define EXPORTTCL "TCL_LIBRARY=" #define EXPORTTK "TK_LIBRARY=" char *pathToTk=(char*)MALLOC((strlen(DIRECTORYOFTK)+commonPart)*sizeof(char)); sprintf(pathToTk, "%s%s%s%s", sciPath, BASEPATHTOTHIRDPARTY, DIRECTORYOFTK, TCL_VERSION); char *exportTcl=(char*)MALLOC((strlen(EXPORTTCL)+strlen(pathToTcl)+1)*sizeof(char)); char *exportTk=(char*)MALLOC((strlen(EXPORTTK)+strlen(pathToTk)+1)*sizeof(char)); sprintf(exportTcl,"%s%s",EXPORTTCL,pathToTcl); sprintf(exportTk,"%s%s",EXPORTTK,pathToTk); /* Export both TCL_LIBRARY & TK_LIBRARY */ putenv(exportTcl); putenv(exportTk); } #endif #endif #endif /* set TMPDIR */ C2F(settmpdir)(); /* For the initialization of the Scilab primivite : fromjava() */ SetFromJavaToON(); InitializeLaunchScilabSignal(); /* Scilab Initialization */ C2F(inisci)(&iflag,&stacksize,&ierr); if ( ierr > 0 ) { fprintf(stderr,"Scilab initialization failed !\n"); exit(1); } /* Load of Scilab.start */ C2F(scirun)(initstr,(int)strlen(initstr)); }
bool CHttpServer::decide(String const &method, String const &arg_uri, String const &query, HeaderList const &headers, String const &body/*, IResponseSender& respSender*/ ) { if (verbose) RAWTRACE1("Decide what to do with uri %s", arg_uri.c_str()); callback_t callback = registered(arg_uri); if (callback) { if (verbose) RAWTRACE1("Uri %s is registered callback, so handle it appropriately", arg_uri.c_str()); if ( callback == rho_http_ruby_proc_callback ) call_ruby_proc( query, body ); else callback(this, query.length() ? query : body); return false; } String uri = arg_uri; String fullPath = CFilePath::join(m_root, uri); #ifndef RHO_NO_RUBY_API if (rho_ruby_is_started()) { Route route; if (dispatch(uri, route)) { if (verbose) RAWTRACE1("Uri %s is correct route, so enable MVC logic", uri.c_str()); VALUE req = create_request_hash(route.application, route.model, route.action, route.id, method, uri, query, headers, body); VALUE data = callFramework(req); String reply(getStringFromValue(data), getStringLenFromValue(data)); rho_ruby_releaseValue(data); bool isRedirect = String_startsWith(reply, "HTTP/1.1 301") || String_startsWith(reply, "HTTP/1.1 302"); if (!send_response(reply, isRedirect)) return false; if (method == "GET") rho_rhodesapp_keeplastvisitedurl(uri.c_str()); if ( sync::RhoconnectClientManager::haveRhoconnectClientImpl() ) { if (!route.id.empty()) { sync::RhoconnectClientManager::rho_sync_addobjectnotify_bysrcname(route.model.c_str(), route.id.c_str()); } } return true; } if (isdir(fullPath)) { if (verbose) RAWTRACE1("Uri %s is directory, redirecting to index", uri.c_str()); String q = query.empty() ? "" : "?" + query; HeaderList headers; headers.push_back(Header("Location", CFilePath::join( uri, "index" RHO_ERB_EXT) + q)); send_response(create_response("301 Moved Permanently", headers), true); return false; } if (isindex(uri)) { if (!isfile(fullPath)) { if (verbose) RAWLOG_ERROR1("The file %s was not found", fullPath.c_str()); String error = "<!DOCTYPE html><html><font size=\"+4\"><h2>404 Not Found.</h2> The file " + uri + " was not found.</font></html>"; send_response(create_response("404 Not Found",error)); return false; } if (verbose) RAWTRACE1("Uri %s is index file, call serveIndex", uri.c_str()); VALUE req = create_request_hash(route.application, route.model, route.action, route.id, method, uri, query, headers, body); VALUE data = callServeIndex((char *)fullPath.c_str(), req); String reply(getStringFromValue(data), getStringLenFromValue(data)); rho_ruby_releaseValue(data); if (!send_response(reply)) return false; if (method == "GET") rho_rhodesapp_keeplastvisitedurl(uri.c_str()); return true; } } #endif // Try to send requested file if (verbose) RAWTRACE1("Uri %s should be regular file, trying to send it", uri.c_str()); PROF_START("READ_FILE"); bool bRes = send_file(uri, headers); PROF_STOP("READ_FILE"); return bRes; }
/************************************************************** * 寄信給站上使用者 **************************************************************/ static int SendMail_Local(char *fname,char *from, const char *to, char *title, char ident) { USEREC urcTmp; char pathTmp[PATHLEN]; int retval, fsize; retval = CheckMail(&urcTmp, to, FALSE); if (retval == -1) return -1; /* kmwang:20000610:blacklist */ /* bug fixed by lasehu 2002/05/22 if (in_blacklist(to, from)) return -1; */ if (!is_emailaddr(from) && in_blacklist(to, from)) return -1; else if (retval > 0) { bbslog("SENDMAIL", "from=%s, to=%s, total=%d, stat=ENOSPC", from, to, retval); return -2; } /* Auto-Forward */ if ((urcTmp.flags[0] & FORWARD_FLAG) && is_emailaddr(urcTmp.email)) { #ifdef NSYSUBBS if (strncmp(urcTmp.email, "bbs@", 4) && !strstr(urcTmp.email, "..")) { #endif if (SendMail_Internet(-1, fname, from, urcTmp.email, title, urcTmp.userid) == 0) return 0; #ifdef NSYSUBBS } #endif bbslog("ERR", "auto-forward: %s", urcTmp.email); } setmailfile(pathTmp, to, NULL); if (!isdir(pathTmp)) { if (mkdir(pathTmp, 0700) == -1) return -1; } if (!(fsize = get_num_records(fname, sizeof(char)))) return -2; if (fsize > MAX_MAIL_SIZE) { bbslog("SENDMAIL", "from=%s, to=%s, size=%d, stat=EFBIG", from, to, fsize); return -3; } #ifdef USE_THREADING /* syhu */ if (append_article(fname, pathTmp, from, title, ident, NULL, FALSE, 0, NULL, -1, -1 ) == -1) /* syhu */ #else if (append_article(fname, pathTmp, from, title, ident, NULL, FALSE, 0, NULL) == -1) #endif return -1; return 0; }
static int pkgxfer(char *srcinst, int options) { int r; struct pkginfo info; FILE *fp, *pp; char *pt, *src, *dst; char dstdir[PATH_MAX], temp[PATH_MAX], srcdir[PATH_MAX], cmd[CMDSIZE], pkgname[NON_ABI_NAMELNGTH]; int i, n, part, nparts, maxpartsize, curpartcnt, iscomp; char volnos[128], tmpvol[128]; struct statvfs64 svfsb; longlong_t free_blocks; struct stat srcstat; info.pkginst = NULL; /* required initialization */ /* * when this routine is entered, the first part of * the package to transfer is already available in * the directory indicated by 'src' --- unless the * source device is a datstream, in which case only * the pkginfo and pkgmap files are available in 'src' */ src = srcdev.dirname; dst = dstdev.dirname; if (!(options & PT_SILENT)) (void) fprintf(stderr, pkg_gt(MSG_TRANSFER), srcinst); (void) strlcpy(dstinst, srcinst, sizeof (dstinst)); if (!(options & PT_ODTSTREAM)) { /* destination is a (possibly mounted) directory */ (void) snprintf(dstdir, sizeof (dstdir), "%s/%s", dst, dstinst); /* * need to check destination directory to assure * that we will not be duplicating a package which * already resides there (though we are allowed to * overwrite the same version) */ pkgdir = src; if (fpkginfo(&info, srcinst)) { progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_NOEXISTS), srcinst); (void) fpkginfo(&info, NULL); return (1); } pkgdir = dst; (void) strlcpy(temp, srcinst, sizeof (temp)); if (pt = strchr(temp, '.')) *pt = '\0'; (void) strlcat(temp, ".*", sizeof (temp)); if (pt = fpkginst(temp, info.arch, info.version)) { /* * the same instance already exists, although * its pkgid might be different */ if (options & PT_OVERWRITE) { (void) strlcpy(dstinst, pt, sizeof (dstinst)); (void) snprintf(dstdir, sizeof (dstdir), "%s/%s", dst, dstinst); } else { progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_DUPVERS), srcinst); (void) fpkginfo(&info, NULL); (void) fpkginst(NULL); return (2); } } else if (options & PT_RENAME) { /* * find next available instance by appending numbers * to the package abbreviation until the instance * does not exist in the destination directory */ if (pt = strchr(temp, '.')) *pt = '\0'; for (i = 2; (access(dstdir, 0) == 0); i++) { (void) snprintf(dstinst, sizeof (dstinst), "%s.%d", temp, i); (void) snprintf(dstdir, sizeof (dstdir), "%s/%s", dst, dstinst); } } else if (options & PT_OVERWRITE) { /* * we're allowed to overwrite, but there seems * to be no valid package to overwrite, and we are * not allowed to rename the destination, so act * as if we weren't given permission to overwrite * --- this keeps us from removing a destination * instance which is named the same as the source * instance, but really reflects a different pkg! */ options &= (~PT_OVERWRITE); } (void) fpkginfo(&info, NULL); (void) fpkginst(NULL); if (ckoverwrite(dst, dstinst, options)) return (2); if (isdir(dstdir) && mkdir(dstdir, 0755)) { progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_MKDIR), dstdir); return (1); } (void) snprintf(srcdir, sizeof (srcdir), "%s/%s", src, srcinst); if (stat(srcdir, &srcstat) != -1) { if (chmod(dstdir, (srcstat.st_mode & S_IAMB)) == -1) { progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_CHMODDIR), dstdir); return (1); } } else { progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_STATDIR), srcdir); return (1); } } if (!(options & PT_SILENT) && strcmp(dstinst, srcinst)) (void) fprintf(stderr, pkg_gt(MSG_RENAME), dstinst); (void) snprintf(srcdir, sizeof (srcdir), "%s/%s", src, srcinst); if (chdir(srcdir)) { progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_CHDIR), srcdir); return (1); } if (ids_name) { /* unpack the datatstream into a directory */ /* * transfer pkginfo & pkgmap first */ (void) snprintf(cmd, sizeof (cmd), "%s -pudm %s", CPIOPROC, dstdir); if ((pp = epopen(cmd, "w")) == NULL) { rpterr(); progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_POPEN), cmd, errno); return (1); } (void) fprintf(pp, "%s\n%s\n", PKGINFO, PKGMAP); (void) sighold(SIGINT); (void) sighold(SIGHUP); r = epclose(pp); (void) sigrelse(SIGINT); (void) sigrelse(SIGHUP); if (r != 0) { rpterr(); progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_PCLOSE), cmd, errno); return (1); } if (options & PT_INFO_ONLY) return (0); /* don't transfer objects */ if (chdir(dstdir)) { progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_CHDIR), dstdir); return (1); } /* * for each part of the package, use cpio() to * unpack the archive into the destination directory */ nparts = ds_findpkg(srcdev.cdevice, srcinst); if (nparts < 0) { progerr(pkg_gt(ERR_TRANSFER)); return (1); } for (part = 1; part <= nparts; /* void */) { if (ds_getpkg(srcdev.cdevice, part, dstdir)) { progerr(pkg_gt(ERR_TRANSFER)); return (1); } part++; if (dstdev.mount) { (void) chdir("/"); if (pkgumount(&dstdev)) return (1); if (part <= nparts) { if (n = pkgmount(&dstdev, NULL, part+1, nparts, 1)) return (n); if (ckoverwrite(dst, dstinst, options)) return (1); if (isdir(dstdir) && mkdir(dstdir, 0755)) { progerr( pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_MKDIR), dstdir); return (1); } /* * since volume is removable, each part * must contain a duplicate of the * pkginfo file to properly identify the * volume */ if (chdir(srcdir)) { progerr( pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_CHDIR), srcdir); return (1); } if ((pp = epopen(cmd, "w")) == NULL) { rpterr(); progerr( pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_POPEN), cmd, errno); return (1); } (void) fprintf(pp, "pkginfo"); (void) sighold(SIGINT); (void) sighold(SIGHUP); r = epclose(pp); (void) sigrelse(SIGINT); (void) sigrelse(SIGHUP); if (r != 0) { rpterr(); progerr( pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_PCLOSE), cmd, errno); return (1); } if (chdir(dstdir)) { progerr( pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_CHDIR), dstdir); return (1); } } } } return (0); } if ((fp = fopen(PKGMAP, "r")) == NULL) { progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_NOPKGMAP), srcinst); return (1); } nparts = 1; if (!rd_map_size(fp, &nparts, &maxpartsize, &compressedsize)) return (1); else (void) fclose(fp); if (srcdev.mount) { if (ckvolseq(srcdir, 1, nparts)) { progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_SEQUENCE)); return (1); } } /* write each part of this package */ if (options & PT_ODTSTREAM) { char line[128]; (void) mgets(line, 128); curpartcnt = -1; /* LINTED E_SEC_SCANF_UNBOUNDED_COPY */ if (sscanf(line, "%s %d %d %[ 0-9]", pkgname, &nparts, &maxpartsize, volnos) == 4) { (void) sscanf(volnos, "%d %[ 0-9]", &curpartcnt, tmpvol); (void) strlcpy(volnos, tmpvol, sizeof (volnos)); } } for (part = 1; part <= nparts; /* void */) { if (curpartcnt == 0 && (options & PT_ODTSTREAM)) { char prompt[128]; int index; ds_volno++; (void) ds_close(0); (void) sprintf(prompt, pkg_gt("Insert %%v %d of %d into %%p"), ds_volno, ds_volcnt); if (n = getvol(ods_name, NULL, DM_FORMAT, prompt)) return (n); if ((ds_fd = open(dstdev.cdevice, O_WRONLY)) < 0) { progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_OPEN), dstdev.cdevice, errno); return (1); } if (ds_ginit(dstdev.cdevice) < 0) { progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_OPEN), dstdev.cdevice, errno); (void) ds_close(0); return (1); } (void) sscanf(volnos, "%d %[ 0-9]", &index, tmpvol); (void) strlcpy(volnos, tmpvol, sizeof (volnos)); curpartcnt += index; } if (options & PT_INFO_ONLY) nparts = 0; if (part == 1) { (void) snprintf(cmd, sizeof (cmd), "find %s %s", PKGINFO, PKGMAP); if (nparts && (isdir(INSTALL) == 0)) { (void) strlcat(cmd, " ", sizeof (cmd)); (void) strlcat(cmd, INSTALL, sizeof (cmd)); } } else (void) snprintf(cmd, sizeof (cmd), "find %s", PKGINFO); if (nparts > 1) { (void) snprintf(temp, sizeof (temp), "%s.%d", RELOC, part); if (iscpio(temp, &iscomp) || isdir(temp) == 0) { (void) strlcat(cmd, " ", sizeof (cmd)); (void) strlcat(cmd, temp, sizeof (cmd)); } (void) snprintf(temp, sizeof (temp), "%s.%d", ROOT, part); if (iscpio(temp, &iscomp) || isdir(temp) == 0) { (void) strlcat(cmd, " ", sizeof (cmd)); (void) strlcat(cmd, temp, sizeof (cmd)); } (void) snprintf(temp, sizeof (temp), "%s.%d", ARCHIVE, part); if (isdir(temp) == 0) { (void) strlcat(cmd, " ", sizeof (cmd)); (void) strlcat(cmd, temp, sizeof (cmd)); } } else if (nparts) { for (i = 0; reloc_names[i] != NULL; i++) { if (iscpio(reloc_names[i], &iscomp) || isdir(reloc_names[i]) == 0) { (void) strlcat(cmd, " ", sizeof (cmd)); (void) strlcat(cmd, reloc_names[i], sizeof (cmd)); } } for (i = 0; root_names[i] != NULL; i++) { if (iscpio(root_names[i], &iscomp) || isdir(root_names[i]) == 0) { (void) strlcat(cmd, " ", sizeof (cmd)); (void) strlcat(cmd, root_names[i], sizeof (cmd)); } } if (isdir(ARCHIVE) == 0) { (void) strlcat(cmd, " ", sizeof (cmd)); (void) strlcat(cmd, ARCHIVE, sizeof (cmd)); } } if (options & PT_ODTSTREAM) { (void) snprintf(cmd + strlen(cmd), sizeof (cmd) - strlen(cmd), " -print | %s -ocD -C %d", CPIOPROC, (int)BLK_SIZE); } else { if (statvfs64(dstdir, &svfsb) == -1) { progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_STATVFS), dstdir, errno); return (1); } free_blocks = (((long)svfsb.f_frsize > 0) ? howmany(svfsb.f_frsize, DEV_BSIZE) : howmany(svfsb.f_bsize, DEV_BSIZE)) * svfsb.f_bavail; if ((has_comp_size ? compressedsize : maxpartsize) > free_blocks) { progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_NOSPACE), has_comp_size ? (long)compressedsize : (long)maxpartsize, free_blocks); return (1); } (void) snprintf(cmd + strlen(cmd), sizeof (cmd) - strlen(cmd), " -print | %s -pdum %s", CPIOPROC, dstdir); } n = esystem(cmd, -1, (options & PT_ODTSTREAM) ? ds_fd : -1); if (n) { rpterr(); progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_CMDFAIL), cmd, n); return (1); } part++; if (srcdev.mount && (nparts > 1)) { /* unmount current source volume */ (void) chdir("/"); if (pkgumount(&srcdev)) return (1); /* loop until volume is mounted successfully */ while (part <= nparts) { /* read only */ n = pkgmount(&srcdev, NULL, part, nparts, 1); if (n) return (n); if (chdir(srcdir)) { progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_CORRUPT)); (void) chdir("/"); (void) pkgumount(&srcdev); continue; } if (ckvolseq(srcdir, part, nparts)) { (void) chdir("/"); (void) pkgumount(&srcdev); continue; } break; } } if (!(options & PT_ODTSTREAM) && dstdev.mount) { /* unmount current volume */ if (pkgumount(&dstdev)) return (1); /* loop until next volume is mounted successfully */ while (part <= nparts) { /* writable */ n = pkgmount(&dstdev, NULL, part, nparts, 1); if (n) return (n); if (ckoverwrite(dst, dstinst, options)) continue; if (isdir(dstdir) && mkdir(dstdir, 0755)) { progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_MKDIR), dstdir); continue; } break; } } if ((options & PT_ODTSTREAM) && part <= nparts) { if (curpartcnt >= 0 && part > curpartcnt) { char prompt[128]; int index; ds_volno++; if (ds_close(0)) return (1); (void) sprintf(prompt, pkg_gt("Insert %%v %d of %d into %%p"), ds_volno, ds_volcnt); if (n = getvol(ods_name, NULL, DM_FORMAT, prompt)) return (n); if ((ds_fd = open(dstdev.cdevice, 1)) < 0) { progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_OPEN), dstdev.cdevice, errno); return (1); } if (ds_ginit(dstdev.cdevice) < 0) { progerr(pkg_gt(ERR_TRANSFER)); logerr(pkg_gt(MSG_OPEN), dstdev.cdevice, errno); (void) ds_close(0); return (1); } (void) sscanf(volnos, "%d %[ 0-9]", &index, tmpvol); (void) strlcpy(volnos, tmpvol, sizeof (volnos)); curpartcnt += index; } } } return (0); }
int MakeTempDir(char path[/*FILENAME_MAX*/], const char* prefix) { int ret; Stroka sysTmp; #ifdef _win32_ if (!prefix || *prefix == '/') { #else if (!prefix) { #endif sysTmp = GetSystemTempDir(); prefix = ~sysTmp; } if ((ret = ResolvePath(prefix, NULL, path, 1)) != 0) return ret; if ((ret = isdir(path)) != 0) return ret; if ((strlcat(path, "tmpXXXXXX", FILENAME_MAX) > FILENAME_MAX - 100)) return EINVAL; if (!(mkdtemp(path))) return errno ? errno : EINVAL; strcat(path, LOCSLASH_S); return 0; } int RemoveTempDir(const char* dirName) { DIR *dir; #ifndef DT_DIR struct stat sbp; #endif if ((dir = opendir(dirName)) == 0) return errno ? errno : ENOENT; int ret; dirent ent, *pent; char path[FILENAME_MAX], *ptr; size_t len = strlcpy(path, dirName, FILENAME_MAX); if (path[len-1] != LOCSLASH_C) { path[len] = LOCSLASH_C; path[++len] = 0; } ptr = path + len; while ((ret = readdir_r(dir, &ent, &pent)) == 0 && pent == &ent) { if (!strcmp(ent.d_name, ".") || !strcmp(ent.d_name, "..")) continue; #ifdef DT_DIR if (ent.d_type == DT_DIR) #else lstat(ent.d_name, &sbp); if (S_ISREG(sbp.st_mode)) #endif { ret = ENOTEMPTY; break; } strcpy(ptr, ent.d_name); if (unlink(path)) { ret = errno ? errno : ENOENT; break; } } closedir(dir); if (ret) return ret; *ptr = 0; if (rmdir(path)) return errno ? errno : ENOTEMPTY; return 0; }