int main(void) { char *cmd; t_node *tree; init_global(); while (!global.status) { tree = NULL; global.prompt = edit_prompt(global.config, global.env); if ((cmd = edit_cmd(&global, global.prompt)) == NULL && !global.status) global.status = !global.status; if (my_strlen(cmd) >= MAX_LINE_NUMBER) fprintf(stderr, "%s: File name too long\n", cmd); else if (!global.status) if (is_singlestr(' ', cmd) && (tree = parsing_func(cmd, &global, 0))) if ((exec_course_tree(tree, global.env, &global)) == EXIT_CHILD) { sh_free(&global, tree, cmd); (global.prompt) ? free(global.prompt) : (global.prompt = NULL); return (global.exit); } sh_free(NULL, tree, cmd); (global.prompt) ? free(global.prompt) : (global.prompt = NULL); } sh_free(&global, NULL, NULL); return (global.exit); }
void CRYPTO_secure_clear_free(void *ptr, size_t num, const char *file, int line) { #ifdef IMPLEMENTED size_t actual_size; if (ptr == NULL) return; if (!CRYPTO_secure_allocated(ptr)) { OPENSSL_cleanse(ptr, num); CRYPTO_free(ptr, file, line); return; } CRYPTO_THREAD_write_lock(sec_malloc_lock); actual_size = sh_actual_size(ptr); CLEAR(ptr, actual_size); secure_mem_used -= actual_size; sh_free(ptr); CRYPTO_THREAD_unlock(sec_malloc_lock); #else if (ptr == NULL) return; OPENSSL_cleanse(ptr, num); CRYPTO_free(ptr, file, line); #endif /* IMPLEMENTED */ }
static int lsendraw(lua_State *L) { int session = luaL_checkinteger(L, 1); int source = luaL_checkinteger(L, 2); int dest = luaL_checkinteger(L, 3); int type = luaL_checkinteger(L, 4); luaL_checktype(L, 5, LUA_TLIGHTUSERDATA); void *msg = lua_touserdata(L, 5); int sz = luaL_checkinteger(L, 6); if (sh_handle_call(session, source, dest, type, msg, sz)) { sh_free(msg); return luaL_error(L, "send %d ~ %d, session:%d, type:%d", source, dest, session, type); } else { sh_free(msg); return 0; } }
static int lsend(lua_State *L) { struct module *ctx = lua_touserdata(L, lua_upvalueindex(1)); assert(ctx); int session = luaL_checkinteger(L, 1); int dest = luaL_checkinteger(L, 2); int type = luaL_checkinteger(L, 3); luaL_checktype(L, 4, LUA_TLIGHTUSERDATA); void *msg = lua_touserdata(L, 4); int sz = luaL_checkinteger(L, 5); if (sh_handle_call(session, ctx->moduleid, dest, type, msg, sz)) { sh_free(msg); return luaL_error(L, "send %d ~ %d, session:%d, type:%d", ctx->moduleid, dest, session, type); } else { sh_free(msg); return 0; } }
DOLPTR freeargs(DOLPTR blk) { register char **argp; register DOLPTR argr = 0; register DOLPTR argblk; if (argblk = blk) { argr = argblk->dolnxt; if ((--argblk->doluse) == 0) { for (argp = (char **) argblk->dolarg; ((intptr_t)(*argp)) != ENDARGS; argp++) { sh_free(*argp); } sh_free(argblk); } } return (argr); }
static int lbroadcast(lua_State *L) { struct module *ctx = lua_touserdata(L, lua_upvalueindex(1)); assert(ctx); int dest = luaL_checkinteger(L, 1); int type = luaL_checkinteger(L, 2); luaL_checktype(L, 3, LUA_TLIGHTUSERDATA); void *msg = lua_touserdata(L, 3); int sz = luaL_checkinteger(L, 4); int n = sh_handle_broadcast(ctx->moduleid, dest, type, msg, sz); lua_pushinteger(L, n); sh_free(msg); return 1; }
void CRYPTO_secure_free(void *ptr, const char *file, int line) { #ifdef OPENSSL_SECURE_MEMORY size_t actual_size; if (ptr == NULL) return; if (!CRYPTO_secure_allocated(ptr)) { CRYPTO_free(ptr, file, line); return; } CRYPTO_THREAD_write_lock(sec_malloc_lock); actual_size = sh_actual_size(ptr); CLEAR(ptr, actual_size); secure_mem_used -= actual_size; sh_free(ptr); CRYPTO_THREAD_unlock(sec_malloc_lock); #else CRYPTO_free(ptr, file, line); #endif /* OPENSSL_SECURE_MEMORY */ }
void CRYPTO_secure_free(void *ptr) { #ifdef IMPLEMENTED size_t actual_size; if (ptr == NULL) return; if (!secure_mem_initialized) { CRYPTO_free(ptr); return; } LOCK(); actual_size = sh_actual_size(ptr); CLEAR(ptr, actual_size); secure_mem_used -= actual_size; sh_free(ptr); UNLOCK(); #else CRYPTO_free(ptr); #endif /* IMPLEMENTED */ }
void check_sharetab() { FILE *f; struct stat st; static timestruc_t last_sharetab_time; timestruc_t prev_sharetab_time; struct share *sh; struct sh_list *shp, *shp_prev; int res, c = 0; /* * read in /etc/dfs/sharetab if it has changed */ if (stat(SHARETAB, &st) != 0) { syslog(LOG_ERR, "Cannot stat %s: %m", SHARETAB); return; } if (st.st_mtim.tv_sec == last_sharetab_time.tv_sec && st.st_mtim.tv_nsec == last_sharetab_time.tv_nsec) { /* * No change. */ return; } /* * Remember the mod time, then after getting the * write lock check again. If another thread * already did the update, then there's no * work to do. */ prev_sharetab_time = last_sharetab_time; (void) rw_wrlock(&sharetab_lock); if (prev_sharetab_time.tv_sec != last_sharetab_time.tv_sec || prev_sharetab_time.tv_nsec != last_sharetab_time.tv_nsec) { (void) rw_unlock(&sharetab_lock); return; } f = fopen(SHARETAB, "r+"); if (f == NULL) { syslog(LOG_ERR, "Cannot open %s: %m", SHARETAB); (void) rw_unlock(&sharetab_lock); return; } /* * Lock the file so that unshare can't * truncate it while we're reading */ if (lockf(fileno(f), F_LOCK, 0L) < 0) { syslog(LOG_ERR, "Cannot lock %s: %m", SHARETAB); (void) rw_unlock(&sharetab_lock); (void) fclose(f); return; } /* * Once we are sure /etc/dfs/sharetab has been * modified, flush netgroup cache entries. */ netgrp_cache_flush(); sh_free(share_list); /* free old list */ share_list = NULL; while ((res = getshare(f, &sh)) > 0) { c++; if (strcmp(sh->sh_fstype, "nfs") != 0) continue; shp = malloc(sizeof (*shp)); if (shp == NULL) goto alloc_failed; if (share_list == NULL) share_list = shp; else /* LINTED not used before set */ shp_prev->shl_next = shp; shp_prev = shp; shp->shl_next = NULL; shp->shl_sh = sharedup(sh); if (shp->shl_sh == NULL) goto alloc_failed; } if (res < 0) syslog(LOG_ERR, "%s: invalid at line %d\n", SHARETAB, c + 1); if (stat(SHARETAB, &st) != 0) { syslog(LOG_ERR, "Cannot stat %s: %m", SHARETAB); (void) rw_unlock(&sharetab_lock); return; } last_sharetab_time = st.st_mtim; (void) fclose(f); (void) rw_unlock(&sharetab_lock); return; alloc_failed: syslog(LOG_ERR, "check_sharetab: no memory"); sh_free(share_list); share_list = NULL; (void) fclose(f); (void) rw_unlock(&sharetab_lock); }
void free_hash_node(sh_ptr_t<sh_hash_node_t> pNode) { sh_free(pNode->pValue); sh_free(pNode); }