int pipe_exec_fg(char const **argv, int in, int out) { int pid; pid = fork(); if (pid < 0) { ropen(0, fd_rp(in), STAT_READER); ropen(1, fd_rp(out), STAT_WRITER); if (execv(argv[0], argv)) { if (errno == ENOENT) { fprintf(stderr, "%s: %s: command not found\n", getname_s(), argv[0]); } else { perror(argv[0]); } abort(); } } close(in); close(out); mwait(PORT_CHILD, pid); return 0; }
static void handle_copy(struct cfg *cf, struct rtpp_session *spa, int idx, char *rname) { if (spa->rrcs[idx] == NULL) { spa->rrcs[idx] = ropen(cf, spa, rname, idx); rtpp_log_write(RTPP_LOG_INFO, spa->log, "starting recording RTP session on port %d", spa->ports[idx]); } if (spa->rtcp->rrcs[idx] == NULL && cf->rrtcp != 0) { spa->rtcp->rrcs[idx] = ropen(cf, spa->rtcp, rname, idx); rtpp_log_write(RTPP_LOG_INFO, spa->log, "starting recording RTCP session on port %d", spa->rtcp->ports[idx]); } }
/////////////////////////////////////////////////////////////////////// // Class : CRenderer // Method : getPhotonMap // Description : Load a photon map // Return Value : // Comments : CPhotonMap *CRenderer::getPhotonMap(const char *name) { CFileResource *map; char fileName[OS_MAX_PATH_LENGTH]; FILE *in; assert(name != NULL); assert(frameFiles != NULL); // Check the cache to see if the file is in the memory if (frameFiles->find(name,map) == FALSE) { // Locate the file if (locateFile(fileName,name,texturePath)) { // Try to open the file in = ropen(fileName,"rb",filePhotonMap,TRUE); } else { in = NULL; } // Read it map = new CPhotonMap(name,in); frameFiles->insert(map->name,map); } return (CPhotonMap *) map; }
static void logit(const char *filename, int addcwd) { static int logfd = -1; char *p = getenv("DEPMAKER"); char buf[1024]; char buf2[1024]; if (!p) return; if (logfd == -1) { int (*ropen)(const char *, int , int ); ropen = dlsym((void *)-1, "open"); logfd = ropen(p, O_WRONLY|O_CREAT|O_APPEND, 0644); } buf[0] = 0; if (addcwd && filename[0] != '/') { getcwd(buf2, sizeof(buf2)); strlcat(buf,buf2,sizeof(buf)); strlcat(buf,"/",sizeof(buf)); } strlcat(buf, filename, sizeof(buf)); strlcat(buf, "\n", sizeof(buf)); write(logfd, buf, strlen(buf)); }
/* * Try to open a file for reading in the current * directory and all include paths */ int filelist_ropen(const stringsize_t *name) { includePathscnt_t cnt0; stringsize_t namelen; stringsize_t inclen; int fdes; char *cbuf, *cpos; namelen = *name; if( (cbuf=(char*)malloc(includeMaxLen+namelen+1))==NULL ) { systemError(EM_OutOfMemory); return -1; } /* copy name to cbuf */ memcpy( cbuf+includeMaxLen, (const char*)(name+1), namelen ); /* terminate the string */ *(cbuf+includeMaxLen+namelen) = '\0'; if( (fdes=ropen(cbuf+includeMaxLen))!=-1 ) { free(cbuf); return fdes; } for( cnt0=0; cnt0<includePaths_count; ++cnt0 ) { cpos= cbuf+includeMaxLen-(inclen=*(*(includePaths+cnt0))); memcpy( cpos, *(includePaths+cnt0)+1, inclen ); if( (fdes=ropen(cpos))!=-1 ) { break; } } free(cbuf); return fdes; }
void *load_exec(const char *name) { int fd; uint64_t size; char *path; void *image; /* attempt to find requested file */ if (name[0] == '/' || name[0] == '@') { path = strdup(name); } else { path = strvcat(getenv("PATH"), "/", name, NULL); } fd = ropen(-1, fs_find(path), STAT_READER); if (fd < 0 || !rp_type(fd_rp(fd), "file")) { /* file not found */ return NULL; } else { /* read whole file into buffer */ size = rp_size(fd_rp(fd)); if (!size) { return NULL; } image = aalloc(size, PAGESZ); if (!image) { return NULL; } if (rp_read(fd_rp(fd), image, size, 0) != size) { free(image); close(fd); return NULL; } close(fd); return image; } }
/////////////////////////////////////////////////////////////////////// // Class : CIrradianceCache // Method : CIrradianceCache // Description : Ctor // Return Value : // Comments : CIrradianceCache::CIrradianceCache(const char *name,unsigned int f,FILE *in,const float *from,const float *to,const float *tondc) : CTexture3d(name,from,to,tondc,3,cacheChannels) { int i; assert(dataSize == 7); assert(numChannels == 3); memory = new CMemStack; // Where we allocate our memory from root = NULL; maxDepth = 1; flags = f; osCreateMutex(mutex); // Are we reading from file ? if (flags & CACHE_READ) { if (in == NULL) in = ropen(name,"rb",fileIrradianceCache); if (in != NULL) { // Read the samples fread(&maxDepth, sizeof(int),1,in); root = readNode(in); // Close the file fclose(in); } } // Are we creating a fresh cache ? if (root == NULL) { vector center,bmin,bmax; // Transform the bounding box to the world transformBound(bmin,bmax,to,CRenderer::worldBmin,CRenderer::worldBmax); root = (CCacheNode *) memory->alloc(sizeof(CCacheNode)); for (i=0;i<8;i++) root->children[i] = NULL; addvv(center,bmin,bmax); mulvf(center,0.5f); movvv(root->center,center); subvv(bmax,bmin); root->side = max(max(bmax[0],bmax[1]),bmax[2]); root->samples = NULL; } }
/* this handles exec calls */ void _init(void) { char buf[1024]; int (*ropen)(const char *, int , int ); int fd, i, len; if (realpath("/proc/self/exe", buf)) { logit(buf, 1); } ropen = dlsym((void *)-1, "open"); fd = ropen("/proc/self/cmdline", O_RDONLY, 0); strcpy(buf,"COMMAND: "); len = read(fd, buf+9, sizeof(buf)-10); for (i=0;i<len;i++) if (buf[9+i] == 0) buf[9+i] = ' '; buf[9+len] = 0; logit(buf, 0); }
/////////////////////////////////////////////////////////////////////// // Class : CIrradianceCache // Method : ~CIrradianceCache // Description : Dtor // Return Value : // Comments : CIrradianceCache::~CIrradianceCache() { osDeleteMutex(mutex); // Are we writing the file out ? if (flags & CACHE_WRITE) { if (name[0] != 0) { FILE *out = ropen(name,"wb",fileIrradianceCache); if (out != NULL) { // Write the samples fwrite(&maxDepth, sizeof(int),1,out); writeNode(out,root); fclose(out); } } } // Delete the memory pool delete memory; }
void connectHandler(int socket) { struct packedHedderFormat packedHedder; int isAuthenticated = 0; char tkeyForTest[32]; int i,n; int intrespons; int count = 0; container *attrkeys = NULL; #ifdef DEBUG_TIME struct timeval start_time, end_time; struct timeval tot_start_time, tot_end_time; gettimeofday(&tot_start_time, NULL); #endif ionice_benice(); while ((i=recv(socket, &packedHedder, sizeof(struct packedHedderFormat),MSG_WAITALL)) > 0) { #ifdef DEBUG printf("size is: %i\nversion: %i\ncommand: %i\n",packedHedder.size,packedHedder.version,packedHedder.command); #endif packedHedder.size = packedHedder.size - sizeof(packedHedder); if (attrkeys == NULL) { attrkeys = ropen(); } if (packedHedder.command == bbc_askToAuthenticate) { if ((i=recv(socket, tkeyForTest, sizeof(tkeyForTest),MSG_WAITALL)) == -1) { perror("Cant read tkeyForTest"); exit(1); } if (1) { printf("authenticated\n"); intrespons = bbc_authenticate_ok; bbdocument_init(NULL); isAuthenticated = 1; } else { printf("authenticate faild\n"); intrespons = bbc_authenticate_feiled; } if ((n=sendall(socket, &intrespons, sizeof(intrespons))) == -1) { perror("Cant recv filerest"); exit(1); } } else { if (!isAuthenticated) { printf("user not autentikated\n"); exit(1); } if (packedHedder.command == bbc_docadd) { #ifdef DEBUG printf("bbc_docadd\n"); #endif char *subname,*documenturi,*documenttype,*document,*acl_allow,*acl_denied,*title,*doctype; char *attributes; int dokument_size; unsigned int lastmodified; #ifdef DEBUG_TIME gettimeofday(&start_time, NULL); #endif //subname if ((i=recvall(socket, &intrespons, sizeof(intrespons))) == 0) { perror("Cant read intrespons"); exit(1); } subname = malloc(intrespons +1); if ((i=recvall(socket, subname, intrespons)) == 0) { perror("Cant read subname"); exit(1); } //documenturi if ((i=recvall(socket, &intrespons, sizeof(intrespons))) == 0) { perror("Cant read intrespons"); exit(1); } documenturi = malloc(intrespons +1); if ((i=recvall(socket, documenturi, intrespons)) == 0) { perror("Cant read documenturi"); exit(1); } //documenttype if ((i=recvall(socket, &intrespons, sizeof(intrespons))) == 0) { perror("Cant read intrespons"); exit(1); } documenttype = malloc(intrespons +1); if ((i=recvall(socket, documenttype, intrespons)) == 0) { perror("Cant read documenttype"); exit(1); } //document //dokument_size if ((i=recvall(socket, &dokument_size, sizeof(dokument_size))) == 0) { perror("Cant read dokument_size"); exit(1); } document = malloc(dokument_size +1); if (dokument_size == 0) { document[0] = '\0'; } else { if ((i=recvall(socket, document, dokument_size)) == 0) { fprintf(stderr,"Can't read document of size %i\n",dokument_size); perror("recvall"); exit(1); } } //lastmodified if ((i=recvall(socket, &lastmodified, sizeof(lastmodified))) == 0) { perror("Cant read lastmodified"); exit(1); } //acl_allow if ((i=recvall(socket, &intrespons, sizeof(intrespons))) == 0) { perror("Cant read intrespons"); exit(1); } acl_allow = malloc(intrespons +1); if ((i=recvall(socket, acl_allow, intrespons)) == 0) { perror("Cant read acl_allow"); exit(1); } //acl_denied if ((i=recvall(socket, &intrespons, sizeof(intrespons))) == 0) { perror("Cant read intrespons"); exit(1); } acl_denied = malloc(intrespons +1); if ((i=recvall(socket, acl_denied, intrespons)) == 0) { perror("Cant read acl_denied"); exit(1); } //title if ((i=recvall(socket, &intrespons, sizeof(intrespons))) == 0) { perror("Cant read intrespons"); exit(1); } title = malloc(intrespons +1); if ((i=recvall(socket, title, intrespons)) == 0) { perror("Cant read title"); exit(1); } //doctype if ((i=recvall(socket, &intrespons, sizeof(intrespons))) == 0) { perror("Cant read intrespons"); exit(1); } doctype = malloc(intrespons +1); if ((i=recvall(socket, doctype, intrespons)) == 0) { perror("Cant read doctype"); exit(1); } // Attribute list if ((i = recvall(socket, &intrespons, sizeof(intrespons))) == 0) err(1, "Can't receive attribute list len"); attributes = malloc(intrespons +1); if ((i=recvall(socket, attributes, intrespons)) == 0) err(1, "Can't receive attribute list"); #ifdef DEBUG_TIME gettimeofday(&end_time, NULL); printf("Time debug: bbdn_docadd recv data time: %f\n",getTimeDifference(&start_time, &end_time)); #endif printf("\n"); printf("########################################################\n"); printf("Url: %s\n",documenturi); printf("got subname \"%s\": title \"%s\". Nr %i, dokument_size %i attrib: %s\n",subname,title,count,dokument_size, attributes); printf("########################################################\n"); printf("calling bbdocument_add():\n"); #ifdef DEBUG_TIME gettimeofday(&start_time, NULL); #endif intrespons = bbdocument_add(subname,documenturi,documenttype,document,dokument_size,lastmodified,acl_allow,acl_denied,title,doctype, attributes, attrkeys); printf(":bbdocument_add end\n"); printf("########################################################\n"); #ifdef DEBUG_TIME gettimeofday(&end_time, NULL); printf("Time debug: bbdn_docadd runing bbdocument_add() time: %f\n",getTimeDifference(&start_time, &end_time)); #endif free(subname); free(documenturi); free(documenttype); free(document); free(acl_allow); free(acl_denied); free(title); free(doctype); free(attributes); // send status if ((n=sendall(socket, &intrespons, sizeof(intrespons))) == -1) { perror("Cant recv filerest"); exit(1); } } else if (packedHedder.command == bbc_opencollection) { char *subname; char path[PATH_MAX]; printf("open collection\n"); if ((i=recv(socket, &intrespons, sizeof(intrespons),MSG_WAITALL)) == -1) err(1, "Cant read intrespons"); subname = malloc(intrespons +1); if ((i=recv(socket, subname, intrespons,MSG_WAITALL)) == -1) err(1, "Cant read subname"); GetFilPathForLot(path, 1, subname); strcat(path, "fullyCrawled"); unlink(path); free(subname); } else if (packedHedder.command == bbc_closecollection) { printf("closecollection\n"); char *subname; //subname if ((i=recv(socket, &intrespons, sizeof(intrespons),MSG_WAITALL)) == -1) { perror("Cant read intrespons"); exit(1); } subname = malloc(intrespons +1); if ((i=recv(socket, subname, intrespons,MSG_WAITALL)) == -1) { perror("Cant read subname"); exit(1); } bbdocument_close(attrkeys); attrkeys = NULL; //toDo må bruke subname, og C ikke perl her printf("cleanin lots start\n"); char command[PATH_MAX]; snprintf(command,sizeof(command),"perl %s -l -s \"%s\"",bfile("perl/cleanLots.pl"),subname); printf("running \"%s\"\n",command); intrespons = system(command); printf("cleanin lots end\n"); // legger subnamet til listen over ventene subnavn, og huper searchd. lot_recache_collection(subname); /* We are done crawling */ { int fd = lotOpenFileNoCasheByLotNrl(1, "fullyCrawled", ">>", '\0', subname); if (fd == -1) { warn("Unable to write fullyCrawled file"); } else { close(fd); } } free(subname); if ((n=sendall(socket, &intrespons, sizeof(intrespons))) == -1) { perror("Cant recv filerest"); exit(1); } } else if (packedHedder.command == bbc_deleteuri) { printf("deleteuri\n"); char *subname, *uri; //subname if ((i=recv(socket, &intrespons, sizeof(intrespons),MSG_WAITALL)) == -1) { perror("Cant read intrespons"); exit(1); } subname = malloc(intrespons +1); if ((i=recv(socket, subname, intrespons,MSG_WAITALL)) == -1) { perror("Cant read subname"); exit(1); } subname[intrespons] = '\0'; if ((i=recv(socket, &intrespons, sizeof(intrespons),MSG_WAITALL)) == -1) { perror("Cant read intrespons"); exit(1); } uri = malloc(intrespons +1); if ((i=recv(socket, uri, intrespons,MSG_WAITALL)) == -1) { perror("Cant read uri"); exit(1); } uri[intrespons] = '\0'; printf("going to delete: %s from %s\n", uri, subname); /* Add docid to the gced file */ { FILE *fh; unsigned int DocID, lastmodified; unsigned int lotNr; int err = 0; if (uriindex_get(uri, &DocID, &lastmodified, subname) == 0) { fprintf(stderr,"Unable to get uri info. uri=\"%s\",subname=\"%s\".",uri,subname); perror("Unable to get uri info"); err++; } if (!err) { lotNr = rLotForDOCid(DocID); if ((fh = lotOpenFileNoCasheByLotNr(lotNr,"gced","a", 'e',subname)) == NULL) { perror("can't open gced file"); err++; } else { fwrite(&DocID, sizeof(DocID), 1, fh); fclose(fh); } } if (!err) { struct reformat *re; if((re = reopen(rLotForDOCid(DocID), sizeof(struct DocumentIndexFormat), "DocumentIndex", subname, RE_HAVE_4_BYTES_VERSION_PREFIX)) == NULL) { perror("can't reopen()"); err++; } else { DIS_delete(RE_DocumentIndex(re, DocID)); reclose(re); } } //markerer at den er skitten if (!err) { FILE *dirtfh; dirtfh = lotOpenFileNoCashe(DocID,"dirty","ab",'e',subname); fwrite("1",1,1,dirtfh); fclose(dirtfh); } if (err == 0) bbdocument_delete(uri, subname); } free(subname); intrespons = 1; // Always return ok for now if ((n=sendall(socket, &intrespons, sizeof(intrespons))) == -1) { perror("Cant recv filerest"); exit(1); } } else if (packedHedder.command == bbc_deletecollection) { printf("deletecollection\n"); char *subname, *uri; //subname if ((i=recv(socket, &intrespons, sizeof(intrespons),MSG_WAITALL)) == -1) { perror("Cant read intrespons"); exit(1); } subname = malloc(intrespons +1); if ((i=recv(socket, subname, intrespons,MSG_WAITALL)) == -1) { perror("Cant read subname"); exit(1); } subname[intrespons] = '\0'; printf("going to delete collection: %s\n", subname); intrespons = bbdocument_deletecoll(subname); if ((n=sendall(socket, &intrespons, sizeof(intrespons))) == -1) { perror("Cant recv filerest"); exit(1); } free(subname); } else if (packedHedder.command == bbc_addwhisper) { whisper_t add; char *subname; if ((i=recv(socket, &intrespons, sizeof(intrespons),MSG_WAITALL)) == -1) err(1, "Cant read intrespons"); subname = malloc(intrespons+1); if ((i=recv(socket, subname, intrespons,MSG_WAITALL)) == -1) { perror("Cant read subname"); exit(1); } subname[intrespons] = '\0'; if ((i=recv(socket, &add, sizeof(add),MSG_WAITALL)) == -1) err(1, "Cant read add whisper"); gcwhisper_write(subname, add); free(subname); } else if (packedHedder.command == bbc_HasSufficientSpace) { char *subname; //subname if ((i=recvall(socket, &intrespons, sizeof(intrespons))) == 0) { perror("Cant read intrespons"); exit(1); } subname = malloc(intrespons +1); if ((i=recvall(socket, subname, intrespons)) == 0) { perror("Cant read subname"); exit(1); } // tester bare i lot 1 her. Må også sjekke andre loter når vi begynner å støtte frlere disker på ES. intrespons = lotHasSufficientSpace(1, 4096, subname); if ((n=sendall(socket, &intrespons, sizeof(intrespons))) == -1) { perror("Cant recv filerest"); exit(1); } printf("~Asked for HasSufficientSpace for subname \"%s\". Returnerer %d\n",subname, intrespons); free(subname); } else { printf("unnown comand. %i\n", packedHedder.command); } } ++count; // #ifdef DEBUG_BREAK_AFTER // if (count >= DEBUG_BREAK_AFTER) { // printf("exeting after %i docoments\n",count); // exit(1); // } // #endif } #ifdef DEBUG_TIME gettimeofday(&tot_end_time, NULL); printf("Time debug: bbdn total time time: %f\n",getTimeDifference(&tot_start_time, &tot_end_time)); #endif }
/////////////////////////////////////////////////////////////////////// // Class : CRenderer // Method : getCache // Description : Load a cache // Return Value : // Comments : CTexture3d *CRenderer::getCache(const char *name,const char *mode,const float *from,const float *to) { CFileResource *cache; assert(name != NULL); assert(frameFiles != NULL); // Check the memory first if (frameFiles->find(name,cache) == FALSE) { char fileName[OS_MAX_PATH_LENGTH]; int flags; char type[128]; int createChannel = FALSE; // Process the file mode if (strcmp(mode,"r") == 0) { flags = CACHE_READ| CACHE_SAMPLE; } else if (strcmp(mode,"w") == 0) { flags = CACHE_WRITE | CACHE_SAMPLE; } else if (strcmp(mode,"R") == 0) { flags = CACHE_READ | CACHE_RDONLY; } else if (strcmp(mode,"rw") == 0) { flags = CACHE_READ | CACHE_WRITE | CACHE_SAMPLE; } else { flags = CACHE_SAMPLE; } // Try to read the file cache = NULL; if (flags & CACHE_READ) { // Locate the file if (locateFile(fileName,name,texturePath)) { FILE *in = ropen(fileName,type); if (in != NULL) { // If we're netrendering and writing, treat specially if ((netClient != INVALID_SOCKET) && (flags & CACHE_WRITE)) { flags &= ~CACHE_WRITE; // don't flush cache to disk createChannel = TRUE; if (strncmp(fileName,temporaryPath,strlen(temporaryPath)) == 0) { // it's a temp file, delete it after we're done registerFrameTemporary(fileName,TRUE); } // always remove the file mapping when writing registerFrameTemporary(name,FALSE); } // Create the cache if (strcmp(type,fileIrradianceCache) == 0) { cache = new CIrradianceCache(name,flags,in,from,to,NULL); } else { error(CODE_BUG,"Unable to recognize the file format of \"%s\"\n",name); fclose(in); } } } } // If there is no cache, create it if (cache == NULL) { // If we're netrendering and writing, treat specially if ((netClient != INVALID_SOCKET) && (flags & CACHE_WRITE)) { flags &= ~CACHE_WRITE; // don't flush cache to createChannel = TRUE; // always remove the file mapping when writing registerFrameTemporary(name,FALSE); } // go ahead and create the cache cache = new CIrradianceCache(name,flags,NULL,from,to,CRenderer::toNDC); } // Create channels if possible if (createChannel == TRUE) { if (cache != NULL) { requestRemoteChannel(new CRemoteICacheChannel((CIrradianceCache *) cache)); } } frameFiles->insert(cache->name,cache); } return (CTexture3d *) cache; }
void respond(Req *r, char *error) { int i, m, n; char errbuf[ERRMAX]; Srv *srv; srv = r->srv; assert(srv != nil); if(r->responded){ assert(r->pool); goto free; } assert(r->responded == 0); r->error = error; switch(r->ifcall.type){ default: assert(0); /* * Flush is special. If the handler says so, we return * without further processing. Respond will be called * again once it is safe. */ case Tflush: if(rflush(r, error)<0) return; break; case Tversion: rversion(r, error); break; case Tauth: rauth(r, error); break; case Tattach: rattach(r, error); break; case Twalk: rwalk(r, error); break; case Topen: ropen(r, error); break; case Tcreate: rcreate(r, error); break; case Tread: rread(r, error); break; case Twrite: rwrite(r, error); break; case Tclunk: rclunk(r, error); break; case Tremove: rremove(r, error, errbuf); break; case Tstat: rstat(r, error); break; case Twstat: rwstat(r, error); break; } r->ofcall.tag = r->ifcall.tag; r->ofcall.type = r->ifcall.type+1; if(r->error) setfcallerror(&r->ofcall, r->error); if(chatty9p) fprint(2, "-%d-> %F\n", srv->outfd, &r->ofcall); qlock(&srv->wlock); n = convS2M(&r->ofcall, srv->wbuf, srv->msize); if(n <= 0){ fprint(2, "n = %d %F\n", n, &r->ofcall); abort(); } assert(n > 2); /* * There is a race here - we must remove the entry before * the write, so that if the client is very fast and reuses the * tag, the read loop won't think it is still in use. * * By removing the entry before the write, we open up a * race with incoming Tflush messages. Specifically, an * incoming Tflush might not see r even though it has not * yet been responded to. It would then send an Rflush * immediately, potentially before we do the write. This can't * happen because we already old srv->wlock, so nothing * is going out on the wire before this write. */ if(r->pool) /* not a fake */ closereq(removereq(r->pool, r->ifcall.tag)); qlock(&r->lk); r->responded = 1; if(r->pool) if(r->ref.ref == 1+r->nflush) if(r->fid){ /* * There are no references other than in our r->flush array, * so no one else should be accessing r concurrently. * Close the fid now, before responding to the message. * * If the client is behaving (there are no outstanding T-messages * that reference r->fid) and the message is a Tclunk or Tremove, * then this closefid will call destroyfid. * * This means destroyfid can't piddle around * indefinitely (we're holding srv->wlock!), but it provides * for tighter semantics as to when destroyfid is called. * * LANL has observed cases where waiting until after the write * can delay a closefid on a Twrite for many 9P transactions, * so that a handful of transactions can happen including a Tclunk * and a Topen, and the original fid will still not be destroyed. */ closefid(r->fid); r->fid = nil; } qunlock(&r->lk); m = write(srv->outfd, srv->wbuf, n); if(m != n) sysfatal("lib9p srv: write %d returned %d on fd %d: %r", n, m, srv->outfd); qunlock(&srv->wlock); free: qlock(&r->lk); /* no one will add flushes now */ for(i=0; i<r->nflush; i++){ r->flush[i]->oldreq = nil; /* so it doesn't try to lock us! */ respond(r->flush[i], nil); } free(r->flush); r->flush = nil; r->nflush = 0; qunlock(&r->lk); if(r->pool) closereq(r); else free(r); }
int gcrepo(int LotNr, char *subname) { int i; struct ReposetoryHeaderFormat ReposetoryHeader; char htmlbuffer[524288]; char imagebuffer[524288]; char *acl_allow; char *acl_deny; char *url, *attributes; unsigned long int raddress; char path[1024]; char path2[1024]; char path3[1024]; FILE *FNREPO; struct reformat *re; int keept = 0; int gced = 0; container *attrkeys = ropen(); if((re = reopen(LotNr, sizeof(struct DocumentIndexFormat), "DocumentIndex", subname, RE_HAVE_4_BYTES_VERSION_PREFIX|RE_COPYONCLOSE)) == NULL) { perror("reopen DocumentIndex"); return 0; } if ( (FNREPO = lotOpenFileNoCasheByLotNr(LotNr,"reposetory","rb", 's',subname)) == NULL) { #ifdef DEBUG printf("lot dont have a reposetory file\n"); #endif return 0; } while (rGetNext_fh(LotNr,&ReposetoryHeader,htmlbuffer,sizeof(htmlbuffer),imagebuffer,&raddress,0,0,subname,&acl_allow,&acl_deny, FNREPO ,&url, &attributes)) { #ifdef DEBUG printf("dokument \"%s\", DocID %u.\n", RE_DocumentIndex(re,ReposetoryHeader.DocID)->Url, ReposetoryHeader.DocID); #endif //printf("%p\n", docindex.RepositoryPointer); if (raddress != RE_DocumentIndex(re,ReposetoryHeader.DocID)->RepositoryPointer) { #ifdef DEBUG printf("Garbage collecting %d at %u. docindex has %u\n", ReposetoryHeader.DocID, raddress,RE_DocumentIndex(re,ReposetoryHeader.DocID)->RepositoryPointer); #endif ++gced; } else { unsigned long int offset; offset = rApendPost(&ReposetoryHeader, htmlbuffer, imagebuffer, subname, acl_allow, acl_deny, "repo.wip", url, attributes, attrkeys); RE_DocumentIndex(re,ReposetoryHeader.DocID)->RepositoryPointer = offset; #ifdef DEBUG printf("Writing DocID: %d\n", ReposetoryHeader.DocID); #endif ++keept; } } fclose(FNREPO); //lokker filen repo.wip //lotCloseFiles(); rclose(attrkeys); printf("keept %i\ngced %i\n",keept,gced); reclose(re); /* And we have a race... */ GetFilPathForLot(path, LotNr, subname); strcpy(path2, path); strcpy(path3, path); strcat(path, "repo.wip"); strcat(path2, "reposetory"); rename(path, path2); strcpy(path, path3); strcat(path, "DocumentIndex.wip"); strcat(path3, "DocumentIndex"); rename(path, path3); #ifdef DI_FILE_CASHE closeDICache(); #endif return 0; }
int bbdocument_init(container **attrkeys) { DIR *dirp; FILE *filep; char buf[512]; char path[512]; struct dirent *dp; char lines[512]; char **splitdata; int TokCount; struct fileFilterFormat *fileFilter = NULL; char fileFilterName[] = "fileFilter"; perl_embed_init(NULL, 1); //chtbl_init(&htbl, PRIME_TBLSIZ, bbdocument_h, bbdocument_hmatch, free); h_fileFilter = create_hashtable(PRIME_TBLSIZ, bbdocument_h, bbdocument_hmatch); printf("opening %s\n",bfile(fileFilterName)); if ((dirp = opendir(bfile(fileFilterName))) == NULL) { fprintf(stderr,"warn: cant open fileFilter \"%s\". Cant use fileFilters\n",bfile(fileFilterName)); return 1; } while ((dp = readdir(dirp)) != NULL) { if (dp->d_name[0] == '.') { continue; } sprintf(path,"%s/%s/",bfile(fileFilterName),dp->d_name); sprintf(buf,"%sruninfo",path); printf("%s\n",buf); if ((filep = fopen(buf,"r")) == NULL) { printf("no runinfo file for \"%s\"\n",dp->d_name); continue; } printf("loading \"%s\"\n",dp->d_name); while ((!feof(filep)) && (fgets(lines,sizeof(lines) -1,filep) != NULL)) { //blanke linjer og komentarer som starter på # if ((lines[0] == '\n') || (lines[0] == '#')) { continue; } //void chomp(char string[]) chomp(lines); //printf("line %s\n",lines); TokCount = split(lines, ": ", &splitdata); //printf("\tfound %d token(s):\n", TokCount); /* if (TokCount != 2) { printf("bad config line \"%s\". Splitet in %i elements\n",lines,TokCount); continue; } */ if (strcmp(splitdata[0],"documentstype") == 0) { //legger til det gamle filteret if (fileFilter != NULL) { if (NULL != hashtable_search(h_fileFilter,fileFilter->documentstype )) { printf("####################### BUG ################################\n"); printf("allredy have a filter for \"%s\"!\n",fileFilter->documentstype); printf("#######################/BUG ################################\n"); } //add to hash printf("inserting %s\n",(*fileFilter).documentstype); //chtbl_insert(&htbl,(void *)fileFilter); if (!hashtable_insert(h_fileFilter,fileFilter->documentstype,fileFilter) ) { printf("cant insert\n"); exit(-1); } printf("end inserting\n"); } //begynner på et nytt filter fileFilter = malloc(sizeof(struct fileFilterFormat)); fileFilter->attrwhitelist = NULL; //ikke alle filfiltere har sat alle opsjoner, så vi nulstiller alt, slik at det er lett og strcmp()'e //etter en verdi, uten at vi må tenke på at den kansje ikke er satt. memset(fileFilter,'\0',sizeof(struct fileFilterFormat)); // default til FILTER_EXEOC fileFilter->filtertype = FILTER_EXEOC; strcpy((*fileFilter).documentstype,splitdata[1]); strlcpy(fileFilter->path, path, sizeof fileFilter->path); } else if (strcmp(splitdata[0],"command") == 0) { //vi kan ha : i komandoen. Kopierer derfor først inn hele, så fjerner vi command: //strcpy((*fileFilter).command,splitdata[1]); strscpy((*fileFilter).command,lines,sizeof((*fileFilter).command)); strcasesandr((*fileFilter).command,sizeof((*fileFilter).command),"command: ",""); //leger til path der vi har sakt vi skal ha lokal path ( ./ ) strcasesandr((*fileFilter).command,sizeof((*fileFilter).command),"./",path); printf(".command %s\n",(*fileFilter).command); } else if (strcmp(splitdata[0],"comment") == 0) { strscpy((*fileFilter).comment,splitdata[1],sizeof((*fileFilter).comment)); } else if (strcmp(splitdata[0],"format") == 0) { strscpy((*fileFilter).format,splitdata[1],sizeof((*fileFilter).format)); } else if (strcmp(splitdata[0],"outputtype") == 0) { //stdio, file, osv,, strcpy((*fileFilter).outputtype,splitdata[1]); } else if (strcmp(splitdata[0],"outputformat") == 0) { //text, html strcpy((*fileFilter).outputformat,splitdata[1]); } else if (strcmp(splitdata[0], "filtertype") == 0) { if (strcmp(splitdata[1], FILTER_EXEOC_STR) == 0) fileFilter->filtertype = FILTER_EXEOC; else if (strcmp(splitdata[1], FILTER_PERL_PLUGIN_STR) == 0) fileFilter->filtertype = FILTER_PERL_PLUGIN; else errx(1, "Unknown filtertype %s\n", splitdata[1]); } else if (strcmp(splitdata[0], "attrwhitelist") == 0) { // TODO: Free fileFilter->attrwhitelist if (!split(splitdata[1], ",", &fileFilter->attrwhitelist)) warnx("attrwhitelist was empty."); } else { printf("unknown command \"%s\"\n",lines); } //clean FreeSplitList(splitdata); } if (fileFilter != NULL) { //add to hash printf("inserting %s\n",(*fileFilter).documentstype); //chtbl_insert(&htbl,(void *)fileFilter); if (!hashtable_insert(h_fileFilter,fileFilter->documentstype,fileFilter) ) { printf("cant insert\n"); exit(-1); } printf("end inserting\n"); } //markerer at vi har lagt det til fileFilter = NULL; fclose(filep); } closedir(dirp); if (attrkeys != NULL) { *attrkeys = ropen(); } return 1; }
/////////////////////////////////////////////////////////////////////// // Class : CRenderer // Method : getTexture3d // Description : Get a point cloud or brickmap // Return Value : // Comments : CTexture3d *CRenderer::getTexture3d(const char *name,int write,const char* channels,const float *from,const float *to,int hierarchy) { CFileResource *texture3d; char fileName[OS_MAX_PATH_LENGTH]; FILE *in; assert(name != NULL); assert(frameFiles != NULL); if (frameFiles->find(name,texture3d) == FALSE) { if (from == NULL) { from = world->from; to = world->to; } // If we are writing, it must be a point cloud if (write == TRUE) { if (netClient != INVALID_SOCKET) { CPointCloud *cloud = new CPointCloud(name,world->from,world->to,CRenderer::toNDC,channels,FALSE); texture3d = cloud; // Ensure we unmap the file when done. Do not delete it // as we mark the file to never be written in the server registerFrameTemporary(name,FALSE); requestRemoteChannel(new CRemotePtCloudChannel(cloud)); } else { // alloate a point cloud which will be written to disk texture3d = new CPointCloud(name,from,to,CRenderer::toNDC,channels,TRUE); } } else { // Locate the file if (locateFile(fileName,name,texturePath)) { // Try to open the file if ((in = ropen(fileName,"rb",filePointCloud,TRUE)) != NULL) { if (hierarchy == TRUE) { texture3d = new CPointHierarchy(name,from,to,in); } else { texture3d = new CPointCloud(name,from,to,in); } } else { if ((in = ropen(fileName,"rb",fileBrickMap,TRUE)) != NULL) { texture3d = new CBrickMap(in,name,from,to); } } } else { in = NULL; } if (in == NULL) { // allocate a dummy blank-channel point cloud error(CODE_BADTOKEN,"Cannot find or open Texture3D file \"%s\"\n",name); texture3d = new CPointCloud(name,world->from,world->to,NULL,NULL,FALSE); // remove the dummy mapping once the frame ends registerFrameTemporary(name,FALSE); } } frameFiles->insert(texture3d->name,texture3d); } return (CPointCloud *) texture3d; }
void ioproc0(void *v) { long n; Mfile *mf; uchar mdata[IOHDRSZ + Maxfdata]; Request req; Job *job; USED(v); for(;;){ n = read9pmsg(mfd[0], mdata, sizeof mdata); if(n <= 0){ syslog(0, logfile, "error reading mntpt: %r"); break; } job = newjob(); if(convM2S(mdata, n, &job->request) != n){ freejob(job); continue; } if(debug) syslog(0, logfile, "%F", &job->request); getactivity(&req); req.aborttime = now + 60; /* don't spend more than 60 seconds */ mf = nil; switch(job->request.type){ case Tversion: case Tauth: case Tflush: break; case Tattach: mf = newfid(job->request.fid, 1); if(mf == nil){ sendmsg(job, "fid in use"); goto skip; } break; default: mf = newfid(job->request.fid, 0); if(mf == nil){ sendmsg(job, "unknown fid"); goto skip; } break; } switch(job->request.type){ default: syslog(1, logfile, "unknown request type %d", job->request.type); break; case Tversion: rversion(job); break; case Tauth: rauth(job); break; case Tflush: rflush(job); break; case Tattach: rattach(job, mf); break; case Twalk: rwalk(job, mf); break; case Topen: ropen(job, mf); break; case Tcreate: rcreate(job, mf); break; case Tread: rread(job, mf); break; case Twrite: rwrite(job, mf, &req); break; case Tclunk: rclunk(job, mf); break; case Tremove: rremove(job, mf); break; case Tstat: rstat(job, mf); break; case Twstat: rwstat(job, mf); break; } skip: freejob(job); putactivity(); } }
int main() { struct tar_file *boot_image, *file; char const **argv; uint64_t temp, temp1, temp2; argv = malloc(sizeof(char*) * 4); /* Boot Image */ boot_image = tar_parse((void*) BOOT_IMAGE); /* Dynamic Linker */ file = tar_find(boot_image, "lib/dl.so"); dl_load(file->start); /* Initial Root Filesystem / Device Filesystem / System Filesystem (tmpfs) */ argv[0] = "tmpfs"; argv[1] = NULL; file = tar_find(boot_image, "sbin/tmpfs"); fs_root = start(file, argv); fs_cons("/dev", "dir"); fs_cons("/sys", "dir"); /* Serial Driver */ argv[0] = "serial"; argv[1] = NULL; file = tar_find(boot_image, "sbin/serial"); fs_plink("/dev/serial", start(file, argv), NULL); ropen(1, fs_find("/dev/serial"), STAT_WRITER); ropen(2, fs_find("/dev/serial"), STAT_WRITER); stdout = fdopen(1, "w"); stderr = fdopen(2, "w"); fs_plink("/dev/stderr", fs_find("/dev/serial"), NULL); /* Keyboard Driver */ argv[0] = "kbd"; argv[1] = NULL; file = tar_find(boot_image, "sbin/kbd"); temp = start(file, argv); /* Graphics Driver */ argv[0] = "svga"; argv[1] = NULL; file = tar_find(boot_image, "sbin/svga"); start(file, argv); /* Init control file */ fs_plink("/sys/init", RP_CONS(getpid(), 0), NULL); /* Initrd */ initrd_init(); fs_plink("/dev/initrd", RP_CONS(getpid(), 1), NULL); /* Root filesystem (tarfs) */ argv[0] = "tarfs"; argv[1] = "/dev/initrd"; argv[2] = NULL; file = tar_find(boot_image, "sbin/tarfs"); temp = start(file, argv); /* Link /dev and /sys and change root */ temp1 = fs_find("/dev"); temp2 = fs_find("/sys"); fs_root = temp; fs_plink("/dev", temp1, NULL); fs_plink("/sys", temp2, NULL); /* Terminal Driver */ argv[0] = "biterm"; argv[1] = "/dev/kbd"; argv[2] = "/dev/svga0"; argv[3] = NULL; file = tar_find(boot_image, "sbin/biterm"); fs_plink("/dev/tty", start(file, argv), NULL); /* Temporary filesystem */ argv[0] = "tmpfs"; argv[1] = NULL; file = tar_find(boot_image, "sbin/tmpfs"); fs_plink("/tmp", start(file, argv), NULL); /* Time Driver */ argv[0] = "time"; argv[1] = NULL; file = tar_find(boot_image, "sbin/time"); fs_plink("/dev/time", start(file, argv), NULL); /* Pipe Driver */ argv[0] = "pipe"; argv[1] = NULL; file = tar_find(boot_image, "sbin/pipe"); fs_plink("/sys/pipe", start(file, argv), NULL); setname("init"); mwait(PORT_CHILD, 0); printf("INIT PANIC: system daemon died\n"); for(;;); return 0; }
static void *job_thread(void *arg) { struct mfile *mf; struct job *job = arg; spinlock_lock(&dblock); mf = newfid(job->request.fid); if (debug) fprintf(stderr, "CS:%F", &job->request); switch (job->request.type) { default: fprintf(stderr, "CS:unknown request type %d", job->request.type); break; case Tversion: rversion(job); break; case Tauth: rauth(job); break; case Tflush: rflush(job); break; case Tattach: rattach(job, mf); break; case Twalk: rwalk(job, mf); break; case Topen: ropen(job, mf); break; case Tcreate: rcreate(job, mf); break; case Tread: rread(job, mf); break; case Twrite: rwrite(job, mf); break; case Tclunk: rclunk(job, mf); break; case Tremove: rremove(job, mf); break; case Tstat: rstat(job, mf); break; case Twstat: rwstat(job, mf); break; } spinlock_unlock(&dblock); freejob(job); if (debug) fprintf(stderr, "CS:Job done\n"); return 0; }
void io(void) { volatile long n; volatile uchar mdata[IOHDRSZ + Maxfdata]; Job *volatile job; Mfile *volatile mf; volatile Request req; memset(&req, 0, sizeof req); /* * a slave process is sometimes forked to wait for replies from other * servers. The master process returns immediately via a longjmp * through 'mret'. */ if(setjmp(req.mret)) putactivity(0); req.isslave = 0; stop = 0; while(!stop){ procsetname("%d %s/dns Twrites of %d 9p rpcs read; %d alarms", stats.qrecvd9p, mntpt, stats.qrecvd9prpc, stats.alarms); n = read9pmsg(mfd[0], mdata, sizeof mdata); if(n<=0){ dnslog("error reading 9P from %s: %r", mntpt); sleep(2000); /* don't thrash after read error */ return; } stats.qrecvd9prpc++; job = newjob(); if(convM2S(mdata, n, &job->request) != n){ freejob(job); continue; } mf = newfid(job->request.fid, 0); if(debug) dnslog("%F", &job->request); getactivity(&req, 0); req.aborttime = timems() + Maxreqtm; req.from = "9p"; switch(job->request.type){ default: warning("unknown request type %d", job->request.type); break; case Tversion: rversion(job); break; case Tauth: rauth(job); break; case Tflush: rflush(job); break; case Tattach: rattach(job, mf); break; case Twalk: rwalk(job, mf); break; case Topen: ropen(job, mf); break; case Tcreate: rcreate(job, mf); break; case Tread: rread(job, mf); break; case Twrite: /* &req is handed to dnresolve() */ rwrite(job, mf, &req); break; case Tclunk: rclunk(job, mf); break; case Tremove: rremove(job, mf); break; case Tstat: rstat(job, mf); break; case Twstat: rwstat(job, mf); break; } freejob(job); /* * slave processes die after replying */ if(req.isslave){ putactivity(0); _exits(0); } putactivity(0); } /* kill any udp server, notifier, etc. processes */ postnote(PNGROUP, getpid(), "die"); sleep(1000); }
FILE *fdopen(int fd, const char *mode) { FILE *stream; int status; if (fd < 0) { return NULL; } // check mode if (mode[0] != 'a' && mode[0] != 'w' && mode[0] != 'r') { errno = EINVAL; return NULL; } // check if the object is not a file if (!rp_type(fd_rp(fd), "file")) { errno = EISDIR; return NULL; } status = 0; // check read permissions if (mode[0] == 'r' || mode[1] == '+') { status |= STAT_READER; } // check write permissions if (mode[0] == 'w' || mode[0] == 'a' || mode[1] == '+') { status |= STAT_WRITER; } // open file for real fd = ropen(fd, fd_rp(fd), status); if (fd < 0) { return NULL; } // reset (erase) the file contents if (mode[0] == 'w') { rp_reset(fd_rp(fd)); } stream = calloc(sizeof(FILE), 1); if (!stream) { errno = ENOMEM; return NULL; } stream->fd = fd; stream->mutex = false; stream->position = 0; stream->size = rp_size(fd_rp(fd)); stream->buffer = NULL; stream->buffsize = 0; stream->buffpos = 0; stream->revbuf = EOF; stream->flags = FILE_NBF | FILE_READ; if (mode[0] == 'w' || mode[0] == 'a' || mode[1] == '+') { stream->flags |= FILE_WRITE; } // position the stream properly if (mode[0] == 'a' && mode[1] != '+') { fseek(stream, 0, SEEK_END); } else { fseek(stream, 0, SEEK_SET); } return stream; }
void rfServ_(int acceptSock) { static char fname[] = "rfServ_()"; struct LSFHeader msgHdr; struct LSFHeader buf; struct sockaddr_in from; socklen_t fromLen = sizeof(from); int sock; XDR xdrs; sock = accept(acceptSock, (struct sockaddr *)&from, &fromLen); if (sock < 0) { ls_errlog(stderr, I18N_FUNC_FAIL_MM, fname, "readDecodeHdr_"); closesocket(acceptSock); return; } xdrmem_create(&xdrs, (char *) &buf, sizeof(buf), XDR_DECODE); for (;;) { XDR_SETPOS(&xdrs, 0); if (readDecodeHdr_(sock, (char *)&buf, SOCK_READ_FIX, &xdrs, &msgHdr) < 0) { ls_errlog(stderr, I18N_FUNC_FAIL_MM, fname, "readDecodeHdr_"); closesocket(sock); xdr_destroy(&xdrs); return; } switch (msgHdr.opCode) { case RF_OPEN: ropen(sock, &msgHdr); break; case RF_CLOSE: rclose(sock, &msgHdr); break; case RF_WRITE: rwrite(sock, &msgHdr); break; case RF_READ: rread(sock, &msgHdr); break; case RF_STAT: rstat(sock, &msgHdr); break; case RF_GETMNTHOST: rgetmnthost(sock, &msgHdr); break; case RF_FSTAT: rfstat(sock, &msgHdr); break; case RF_LSEEK: rlseek(sock, &msgHdr); break; case RF_UNLINK: runlink(sock, &msgHdr); break; case RF_TERMINATE: closesocket(sock); return; default: ls_errlog(stderr, _i18n_msg_get(ls_catd, NL_SETN, 602, "%s: Unknown opcode %d"), fname, msgHdr.opCode); xdr_destroy(&xdrs); break; } } }
int main(int argc, char *argv[]) { int fin=-1, fout=-1, f=0; char buf[8192], xstring[128]=""; int rlen, wlen, blen=512, argi, r=0, w=0; for(argi=1; argi<argc || argc==1; argi++) { if (argc==1 || !strcmp(argv[argi], "--help")) { fprintf(stderr, "inlet [-v|-a|-bN|-p1|-p2|--help] <pipename1 in> [-|<pipename2 out>]\n"); fprintf(stderr, "Flags: -v=verbose; -bN=N byte buffer (i.e. -b512); -pN=open pipe N first\n"); fprintf(stderr, " -a=always reopen p1 even if p1 closes (note: p2 will never close)\n"); fprintf(stderr, "Info: inlet reads from pipe1 to pipe2; if pipe1 closes it is reopened automatically.\n"); fprintf(stderr, "Purpose: Trick an application into believing that it is reading from a single file (i.e. pipe2):\n"); fprintf(stderr, " 1) when in fact multiple writers are dynamically opening and closing to pipe1.\n"); fprintf(stderr, " 2) or from a remote shell (i.e. rsh) or remote machine\n"); fprintf(stderr, " while pipe2 is always kept open by the inlet program.\n"); fprintf(stderr, "Notes: Pipes can be created by the mkfifo command.\n"); fprintf(stderr, " Each pipe open is sequentially suspended (i.e. blocked) until another task accesses it.\n"); fprintf(stderr, " O_NDELAY and O_NONBLOCK are not used by inlet (see unix \"man -s 2 open\")\n"); fprintf(stderr, "Example: mkfifo p1 p2; inlet -v -a p1 p2 & ; cat p2 & ; echo hello >p1; echo Konichiwa >p1;\n"); fprintf(stderr, "\n"); exit(1); } else if (!strcmp(argv[argi], "-v")) { vflag=1; } else if (!strcmp(argv[argi], "-a")) { aflag=1; } else if (!strncmp(argv[argi], "-b", 2)) { blen=atoi(argv[argi]+2); } else if (!strcmp(argv[argi], "-p1")) { pflag=1; } else if (!strcmp(argv[argi], "-p2")) { pflag=2; } else if ( strncmp(argv[argi], "-", 1) || strlen(argv[argi])>1) { if (f==0) { f++; r=argi; } else if (f==1) { f++; w=argi; } else { fprintf(stderr, "inlet: unexpected pipename or filename \"%s\"\n", argv[argi]); exit(1); } } } if (f!=2) { fprintf(stderr, "inlet: missing in or out pipe names\n"); exit(1); } if (vflag) { fprintf(stderr, "inlet: bufsize=%d (-b%d)\n", blen, blen); } if (pflag==1) { fin=ropen(argv[r]); fout=wopen(argv[w]); } else { fout=wopen(argv[w]); fin=ropen(argv[r]); } if (vflag) { fprintf(stderr, "inlet: start reading pipe \"%s\" writing to \"%s\"\n", argv[r], argv[w]); } for(;;) { rlen = read(fin, buf, blen); if (vflag) { fprintf(stderr, "inlet: %d=read(\"%s\",buf,%d bytes);\n", rlen, argv[r], blen); } if (rlen==0) { close(fin); if (aflag) { fin=ropen(argv[r]); } else { break; } /* eof on pipe1 */ } else if (rlen<0) { if (vflag) { fprintf(stderr, "inlet: read error from \"%s\"\n", rlen, argv[r]); } perror("inlet: read"); return 1; } wlen=write(fout, buf, rlen); if (vflag) { fprintf(stderr, "inlet: %d=write(\"%s\",buf,%d bytes);\n", wlen, argv[w], rlen); } if (wlen != rlen) { if (vflag) { fprintf(stderr, "inlet: write(\"%s\") length %d != read length %d\n", argv[w], wlen, rlen); } perror("inlet: write"); return 1; } } return 0; }
void respond(Req *r, char *error) { int i, m, n; char errbuf[ERRMAX]; Srv *srv; srv = r->srv; assert(srv != nil); assert(r->responded == 0); r->error = error; switch(r->ifcall.type){ default: assert(0); /* * Flush is special. If the handler says so, we return * without further processing. Respond will be called * again once it is safe. */ case Tflush: if(rflush(r, error)<0) return; break; case Tversion: rversion(r, error); break; case Tauth: rauth(r, error); break; case Tattach: rattach(r, error); break; case Twalk: rwalk(r, error); break; case Topen: ropen(r, error); break; case Tcreate: rcreate(r, error); break; case Tread: rread(r, error); break; case Twrite: rwrite(r, error); break; case Tclunk: rclunk(r, error); break; case Tremove: rremove(r, error, errbuf); break; case Tstat: rstat(r, error); break; case Twstat: rwstat(r, error); break; } r->ofcall.tag = r->ifcall.tag; r->ofcall.type = r->ifcall.type+1; if(r->error) setfcallerror(&r->ofcall, r->error); if(chatty9p) fprint(2, "-%d-> %F\n", srv->outfd, &r->ofcall); qlock(&srv->wlock); n = convS2M(&r->ofcall, srv->wbuf, srv->msize); if(n <= 0){ fprint(2, "n = %d %F\n", n, &r->ofcall); abort(); } assert(n > 2); if(r->pool) /* not a fake */ closereq(removereq(r->pool, r->ifcall.tag)); m = write(srv->outfd, srv->wbuf, n); if(m != n) sysfatal("lib9p srv: write %d returned %d on fd %d: %r", n, m, srv->outfd); qunlock(&srv->wlock); qlock(&r->lk); /* no one will add flushes now */ r->responded = 1; qunlock(&r->lk); for(i=0; i<r->nflush; i++) respond(r->flush[i], nil); free(r->flush); r->flush = nil; r->nflush = 0; if(r->pool) closereq(r); else free(r); }
/* Use script to produce jpeg frames */ void script_animate (int iw) { char buf[SCRIPT_LINE_SIZE],output[SCRIPT_LINE_SIZE],*ptr; int i,hascontent,quality,frames; FILE *fp; glob_t globbuf; strcpy(buf, "scr_anim"); if (!(fp=ropen(buf))) { printf ("\nAnimation script \"%s\" does not exist,\n", buf); xterm_get_focus(iw); clear_stdin_buffer(); if (!strcasecmp("y", readline_gets ("Do you want a default one created (y/n)?","y"))) { numerically_sorted_glob (config_fname, &globbuf); fp=wopen(buf); fprintf (fp, "%d\n", AX_JPG_DEF_QUALITY); for (i=0; i<globbuf.gl_pathc; i++) fprintf (fp, "%s Jpg/%05d.jpg\n", globbuf.gl_pathv[i], i); globfree (&globbuf); fclose(fp); fp = ropen(buf); } else { xterm_release_focus(iw); return; } } if (!(ptr=fgets(buf,SCRIPT_LINE_SIZE,fp))) { printf ("\nThere is nothing in animation script \"%s\".\n", buf); fclose (fp); return; } for (hascontent=i=0; (buf[i]!=EOS) && (ISDIGIT(buf[i]) || ISBLANK(buf[i]) || (buf[i]=='\n')); i++) if (ISALNUM(buf[i])) hascontent=1; if (!hascontent) { printf ("\nThere is no content in animation script \"%s\".\n", buf); fclose (fp); return; } if (buf[i] == EOS) { sscanf (buf, "%d", &quality); if ((quality<0) || (quality>100)) { printf ("\nquality = %d is out of valid range ([0,100]).\n", quality); return; } else printf ("\nquality = %d\n", quality); ptr = fgets(buf,SCRIPT_LINE_SIZE,fp); } else quality = AX_JPG_DEF_QUALITY; frames = 0; /* If bonds are not on now, there is no need to refresh */ temporary_disable_bond = !n[iw].bond_mode; /* cylinder data structure during the rendering. */ while (ptr) { buf[SCRIPT_LINE_CHAR] = EOS; sscanf (buf, "%s %s", config_fname, output); reload_config (iw, FALSE); paint_scene(iw); AX_dump(iw); AX_show(iw); if (str_caseend_with(output,".png")) AX_save_pixmap_as_png (iw,AX_JPG_QUALITY_TO_PNG_LEVEL(quality),output); else if (str_caseend_with(output,".eps")) AX_save_pixmap_as_eps(iw,quality,output); else AX_save_pixmap_as_jpg(iw,quality,output); frames++; ptr = fgets(buf,SCRIPT_LINE_SIZE,fp); } fclose(fp); printf ("%d frames saved.\n\n", frames); if (temporary_disable_bond) { Config_to_3D_Bonds (n[iw].bond_radius); if (n[iw].bond_mode) { bond_xtal_origin_update (iw); bond_atom_color_update(iw); } else { n[iw].bond_xtal_origin_need_update = TRUE; n[iw].bond_atom_color_need_update = TRUE; } temporary_disable_bond = 0; } return; } /* end script_animate() */