void animate_spermicides(char *base) { if (spermicides->first == NULL) return; lst_iitem_t* curSp; int n = 0; for(curSp = spermicides->first; curSp != NULL; curSp = curSp->next) n++; for(curSp = spermicides->first; curSp != NULL; curSp = curSp->next){ destroySprite(curSp->spr, base); if (!check_spermicide_colision(curSp->spr,curSp->spr->y - curSp->spr->yspeed)) { curSp->spr->y -= curSp->spr->yspeed; drawSprite(curSp->spr, base); } else { deleteSprite(curSp->spr); curSp = lst_remove(spermicides, curSp->spr); if (curSp == NULL) break; } } }
int ConnectorFree (c_tree * ct, ident_t ident) { if (ident) lst_remove ( ct, ident); return 1; }
int readFromPipe(int inputPipe, char * buffer, int * terminalPid, TerminalList * termlist) { int len; int op; int statsPipe; double totalTime; TESTTRUE((read(inputPipe, &op, sizeof(int))==sizeof(int)), "Erro no formato do pipe (" _AT_ ")\n"); printf("\nNew operation:\n"); printf("op: %d\n", op); if (op==0) { TESTTRUE((read(inputPipe, &len, sizeof(int)) == sizeof(int)), "Erro no formato do pipe (" _AT_ ")\n"); printf("len: %d\n", len); TESTTRUE((read(inputPipe, terminalPid, sizeof(int)) == sizeof(int)), "Erro no formato do pipe (" _AT_ ")\n"); printf("pid: %d\n", *terminalPid); TESTTRUE((read(inputPipe, buffer, len) == len), "Erro no formato do pipe (" _AT_ ")\n"); buffer[len]=0; return 0; } else if (op==1) { //informacao que foi criado um novo terminal TESTTRUE((read(inputPipe, terminalPid, sizeof(int)) == sizeof(int)), "Erro no formato do pipe (" _AT_ ")\n"); lst_insert(termlist, *terminalPid); printf("pid: %d\n", *terminalPid); return 1; } else if (op==2) { //informacao que foi fechado um terminal TESTTRUE((read(inputPipe, terminalPid, sizeof(int)) == sizeof(int)), "Erro no formato do pipe (" _AT_ ")\n"); lst_remove(termlist, *terminalPid); printf("pid: %d\n", *terminalPid); return 2; } else if (op==3) { //informacao que e para se fechar a par-shell exitCalled = 1; return 3; } else if (op==4) {//recebeu um stats TESTTRUE((read(inputPipe, &len, sizeof(int)) == sizeof(int)), "Erro no formato do pipe (" _AT_ ")\n"); printf("len: %d\n", len); TESTTRUE((read(inputPipe, terminalPid, sizeof(int)) == sizeof(int)), "Erro no formato do pipe (" _AT_ ")\n"); printf("pid: %d\n", *terminalPid); TESTTRUE((read(inputPipe, buffer, len) == len), "Erro no formato do pipe (" _AT_ ")\n"); buffer[len]=0; if ((statsPipe = open(buffer, O_WRONLY)) < 0) { fprintf(stderr, "Erro ao abrir o ficheiro de output " INPUT_FILE "\n"); exit(EXIT_FAILURE); } totalTime = getTotalTime(); if (write(statsPipe, (char*)&runningProcesses, sizeof(int)) != sizeof(int)) { fprintf(stderr, "Warning: erro a escrever para um pipe\n"); } if (write(statsPipe, (char*)&totalTime, sizeof(double)) != sizeof(double)) { fprintf(stderr, "Warning: erro a escrever para um pipe \n"); } if (close(statsPipe)) { fprintf(stderr, "Warning: erro ao fechar um pipe \n"); } return 4; } fprintf(stderr,"Warning: Unknown operator!\n"); return -1; }
void *lst_remove_iterator_node(t_lstiter *it) { void *data; size_t pos; t_node *node; node = it->current; pos = it->pos; lst_iterator_next(it); it->flag = 2; data = lst_remove(it->lst, pos); if (node == it->end) init_iter(it, it->lst, it->dir); else it->pos = pos; return (data); }
/* description: free local resources */ static void _local_chann_close(tun_local_chann_t *c) { tun_local_t *tun = _tun_local(); if (c->node) { _local_chann_closing(c); c->state = LOCAL_CHANN_STATE_NONE; lst_remove(tun->active_lst, c->node); lst_pushl(tun->free_lst, c); c->node = NULL; tun->channs[c->chann_id] = NULL; /* _verbose("chann %d:%d close, (a:%d,f:%d)\n", c->chann_id, c->magic, */ /* lst_count(tun->active_lst), lst_count(tun->free_lst)); */ } }
/** Build the maze by removing walls according to Prim's algorithm. * * @param maze a maze with all walls present. */ static void build_prim(maze_t* maze) { // MST edges and cells. If (a, b) in mst_edges, then (b, a) not in // mst_edges. (a, b) in mst_edges iff a, b both in mst_cells. list356_t* mst_edges = make_list() ; list356_t* mst_cells = make_list() ; // The frontier. This is the collection of edges between cells in the MST // and cells not in the MST. If (a, b) in frontier, then a in mst_cells // and b not in mst_cells. list356_t* frontier = make_list() ; // Choose two adjacent cells at random to put into the MST, then // populate the frontier accordinately. For simplicitly, choose a // cell in the interior of the maze, then randomly choose a direction // for the other cell. cell_t* start = get_cell(maze, random_limit(1, maze->nrows-1), random_limit(1, maze->ncols-1)); unsigned char direction = 1 << random_limit(0, 4) ; cell_t* next = get_neighbor(maze, start, direction) ; /* debug("Removing (%d, %d) - (%d, %d).\n", start->r, start->c, next->r, next->c) ; */ remove_wall(maze, start, direction) ; edge_t init_edge = (edge_t){start, next} ; lst_add(mst_edges, &init_edge) ; lst_add(mst_cells, start) ; lst_add(mst_cells, next) ; for (int d=0; d<4; ++d) { if (directions[d] != direction && is_cell(maze, start, directions[d])) { cell_t* c = get_neighbor(maze, start, directions[d]) ; edge_t* e = malloc(sizeof(edge_t)) ; e->a = start ; e->b = c ; lst_add(frontier, e) ; } } for (int d=0; d<4; ++d) { if (directions[d] != opposite(direction) && is_cell(maze, next, directions[d])) { cell_t* c = get_neighbor(maze, next, directions[d]) ; edge_t* e = malloc(sizeof(edge_t)) ; e->a = next ; e->b = c ; lst_add(frontier, e) ; } } // As long as we don't have all the cells in the MST, choose an // edge in the frontier at random. Put the edge in the MST // and compute the new edges to add to the frontier. while (lst_size(mst_cells) < (maze->nrows)*(maze->ncols)) { int p = random_limit(0, lst_size(frontier)) ; edge_t* edge = lst_get(frontier, p) ; cell_t* old_cell = edge->a ; cell_t* new_cell = edge->b ; /* debug("Removing (%d, %d) - (%d, %d).\n", old_cell->r, old_cell->c, new_cell->r, new_cell->c) ; */ remove_wall(maze, old_cell, get_direction(old_cell, new_cell)) ; lst_add(mst_edges, edge) ; lst_add(mst_cells, new_cell) ; for (int d=0; d<4; ++d) { unsigned char dir = directions[d] ; if (is_cell(maze, new_cell, dir)) { cell_t* adj_cell = get_neighbor(maze, new_cell, dir) ; edge_t* edge2 = malloc(sizeof(edge_t)) ; edge2->a = new_cell ; edge2->b = adj_cell ; if (lst_contains(mst_cells, adj_cell, cell_cmp)) { lst_remove(frontier, edge2, edge_cmp) ; if (adj_cell != old_cell) free(edge2) ; } else { lst_add(frontier, edge2) ; } } } } }
/* * reset_rl_fs_directives() * Functions to remove releaser file policy * for a particular file name. */ int reset_rl_fs_directive( ctx_t *ctx, /* ARGSUSED */ rl_fs_directive_t *rl_fs_directives) /* Not freed in this function */ { releaser_cfg_t *releaser; rl_fs_directive_t *rl_fsname; node_t *node_c; int match_flag = 0; Trace(TR_MISC, "reset releaser's file system directives"); if (ISNULL(rl_fs_directives)) { Trace(TR_ERR, "%s", samerrmsg); return (-1); } /* * read releaser.cmd file to get all * releaser.cmd information. */ if (read_releaser_cfg(&releaser) != 0) { Trace(TR_MISC, "Read of %s failed with error: %s", releaser_file, samerrmsg); return (-1); } /* * Following block traverses rl_fs_dir_list * list, to find if given file system already * exist. It it exist, remove its list from * rl_fs_dir_list. */ node_c = (releaser->rl_fs_dir_list)->head; while (node_c != NULL) { rl_fsname = (rl_fs_directive_t *)node_c ->data; if (strcmp(rl_fsname->fs, rl_fs_directives->fs) == 0) { if (lst_remove(releaser->rl_fs_dir_list, node_c) != 0) { goto error; } free(rl_fsname); match_flag = 1; break; } node_c = node_c->next; } if (match_flag == 0) { samerrno = SE_NO_RL_FS_FOUND; snprintf(samerrmsg, MAX_MSG_LEN, GetCustMsg(SE_NO_RL_FS_FOUND), rl_fs_directives->fs); goto error; } /* * write releaser.cmd with TRUE option * and it will force to write a new releaser.cmd. */ if (write_releaser_cfg(releaser, B_TRUE) != 0) { goto error; } Trace(TR_FILES, "rl_fsname %s is removed from releaser.cmd\n", rl_fs_directives->fs); free_releaser_cfg(releaser); Trace(TR_MISC, "reset releaser's file system directives success"); return (0); error: free_releaser_cfg(releaser); Trace(TR_ERR, "%s", samerrmsg); return (-1); }
/* * filepath may be either a directory or a fully-qualified path. * if it's fully-qualified, only directory entries that sort alphabetically * after the specified file will be returned. * * morefiles will be set if there are more entries left in the directory * after maxentries have been returned. This is intended to let the caller * know they can continue reading. * * Note that the directory may change while we're reading it. If it does, * files that have been added or removed since we started reading it may * not be accurately reflected. */ int list_directory( ctx_t *c, /* ARGSUSED */ int maxentries, char *listDir, /* directory to list */ char *startFile, /* if continuing, start here */ char *restrictions, uint32_t *morefiles, /* OUT */ sqm_lst_t **direntries) /* OUT */ { int rval = 0; int st = 0; DIR *curdir; /* Variable for directory system calls */ dirent64_t *entry; /* Pointer to a directory entry */ dirent64_t *entryp; struct stat64 sout; restrict_t filter = {0}; char *data; /* Pointer to data item to add to list */ node_t *node; sqm_lst_t *lstp = NULL; char buf[MAXPATHLEN + 1]; char *fname; if (ISNULL(listDir, direntries, morefiles)) { return (-1); } *morefiles = 0; /* Set up wildcard restrictions */ rval = set_restrict(restrictions, &filter); if (rval) { return (rval); } curdir = opendir(listDir); /* Set up to ask for directory entries */ if (curdir == NULL) { return (samrerr(SE_NOSUCHPATH, listDir)); } *direntries = lst_create(); /* Return results in this list */ if (*direntries == NULL) { closedir(curdir); return (-1); /* If allocation failed, samerr is set */ } lstp = *direntries; entry = mallocer(sizeof (struct dirent64) + MAXPATHLEN + 1); if (entry == NULL) { closedir(curdir); lst_free(*direntries); *direntries = NULL; return (-1); } /* Walk through directory entries */ while ((rval = readdir64_r(curdir, entry, &entryp)) == 0) { if (entryp == NULL) { break; } fname = (char *)&(entry->d_name[0]); if ((strcmp(fname, ".") == 0) || (strcmp(fname, "..") == 0)) { continue; } /* * If we were given a non-directory, start after * that file alphabetically. */ if (startFile != NULL) { if ((strcmp(fname, startFile)) <= 0) { continue; } } /* Create full pathname and get stat info */ snprintf(buf, sizeof (buf), "%s/%s", listDir, fname); if (lstat64(buf, &sout) != 0) { continue; /* Ignore file which can't be stat'ed */ } /* * think about ways to avoid a double-stat in when we're * fetching file details */ if (check_restrict_stat(fname, &sout, &filter)) { continue; /* Not this entry */ } /* copy to allocated struct */ data = copystr(fname); if (data == NULL) { rval = -1; break; /* samerr already set */ } /* * caller wants all entries for the directory * should there be a top-end limit, to avoid the case where * the directory has millions of entries? */ if (maxentries <= 0) { rval = lst_append(lstp, data); if (rval != 0) { free(data); break; } continue; } /* * Directory may have more entries than requested, so pre-sort * the list so we return the first <n> sorted alphabetically. */ for (node = lstp->head; node != NULL; node = node->next) { st = strcmp(data, (char *)(node->data)); if (st > 0) { continue; } if (st < 0) { rval = lst_ins_before(lstp, node, data); data = NULL; } if ((rval != 0) || (st == 0)) { free(data); data = NULL; } break; } /* entry sorts higher than existing entries */ if (data != NULL) { if (lstp->length < maxentries) { rval = lst_append(lstp, data); if (rval != 0) { free(data); break; } } else { /* no room for this entry */ free(data); (*morefiles)++; } } /* Keep list to designated limits */ if (lstp->length > maxentries) { /* pop off the last entry */ lst_remove(lstp, lstp->tail); (*morefiles)++; } } closedir(curdir); free(entry); if (rval) { lst_free_deep(*direntries); *direntries = NULL; } else if (maxentries <= 0) { lst_qsort(*direntries, node_cmp); } return (rval); }
int callback_home(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len) { struct per_session_data__details *pss = (struct per_session_data__details *)user; switch (reason) { case LWS_CALLBACK_PROTOCOL_INIT:{ break; } case LWS_CALLBACK_FILTER_PROTOCOL_CONNECTION: { check_session(wsi,pss); increment_client_count(); if(lst_find(&clinets_lst,pss->uid)<0){ lst_append(&clinets_lst, pss->user,pss->uid,pss->gid,pss->session_id+24); } break; } case LWS_CALLBACK_WS_PEER_INITIATED_CLOSE: { new_user=pss->user; decrement_client_count(); lst_remove(&clinets_lst,pss->uid); } case LWS_CALLBACK_ESTABLISHED: { dump_user_info(pss); new_user=pss->user; } case LWS_CALLBACK_SERVER_WRITEABLE: { if(strncmp(pss->checked,hash,32)!=0){ memcpy(pss->checked,hash,32); char *out = lst_json(&clinets_lst); int count = strlen(out); unsigned char buffer[LWS_PRE + count]; unsigned char *p = &buffer[LWS_PRE]; int n = sprintf((char *)p, "%s", out); lws_write(wsi, p, n, LWS_WRITE_TEXT); free(out); break; } break; } case LWS_CALLBACK_RECEIVE: { //received_msg = (char *) in; //chalter=1; //lws_callback_on_writable_all_protocol(lws_get_context(wsi),lws_get_protocol(wsi)); break; } default: break; } return 0; }