static int pwd_cmd( FILE *stream, char *response_file ) { char *cwd_buf; int max_len; if (!response_file) { LOG(L_ERR, "ERROR: no file for %s\n", "pwd_cmd" ); return 1; } max_len=pathmax(); cwd_buf=pkg_malloc(max_len); if (!cwd_buf) { LOG(L_ERR, "ERROR: pwd_cmd: no cwd pkg mem\n"); fifo_reply(response_file, "500 no memory\n"); return 1; } if (getcwd(cwd_buf, max_len)) { fifo_reply(response_file, "200 ok\n%s\n", cwd_buf ); } else { fifo_reply(response_file, "500 getcwd failed\n" ); } pkg_free(cwd_buf); return 1; }
static int pwd_cmd(str* msg) { char *cwd_buf; int max_len, ret; max_len = pathmax(); cwd_buf = pkg_malloc(max_len); ret = 0; if (!cwd_buf) { LOG(L_ERR, "pwd_cmd: No memory left\n"); unixsock_reply_asciiz("500 No Memory Left\n"); ret = -1; } if (getcwd(cwd_buf, max_len)) { if (unixsock_reply_printf("200 OK\n%s\n", cwd_buf) < 0) { unixsock_reply_reset(); unixsock_reply_asciiz("500 Error while sending reply\n"); ret = -1; } } else { unixsock_reply_asciiz("500 getcwd Failed\n"); ret = -1; } pkg_free(cwd_buf); if (unixsock_reply_send() < 0) { ret = -1; } return ret; }
/* returns a pkg_malloc'ed file name */ static char* get_name(struct flat_id* id) { char* buf; int buf_len; char* num, *ptr; int num_len; int total_len; buf_len=pathmax(); if (!id) { LM_ERR("invalid parameter value\n"); return 0; } total_len=id->dir.len+1 /* / */+id->table.len+1 /* _ */+ FILE_SUFFIX_LEN+1 /* \0 */; /* without pid*/ if (buf_len<total_len){ LM_ERR("the path is too long (%d and PATHMAX is %d)\n", total_len, buf_len); return 0; } buf=pkg_malloc(buf_len); if (buf==0){ LM_ERR("pkg memory allocation failure\n"); return 0; } ptr = buf; memcpy(ptr, id->dir.s, id->dir.len); ptr += id->dir.len; *ptr++ = '/'; memcpy(ptr, id->table.s, id->table.len); ptr += id->table.len; *ptr++ = '_'; num = int2str(km_flat_pid, &num_len); if (buf_len<(total_len+num_len)){ LM_ERR("the path is too long (%d and PATHMAX is" " %d)\n", total_len+num_len, buf_len); pkg_free(buf); return 0; } memcpy(ptr, num, num_len); ptr += num_len; memcpy(ptr, FILE_SUFFIX, FILE_SUFFIX_LEN); ptr += FILE_SUFFIX_LEN; *ptr = '\0'; return buf; }
static void core_pwd(rpc_t* rpc, void* c) { char *cwd_buf; int max_len; max_len = pathmax(); cwd_buf = pkg_malloc(max_len); if (!cwd_buf) { ERR("core_pwd: No memory left\n"); rpc->fault(c, 500, "Server Ran Out of Memory"); return; } if (getcwd(cwd_buf, max_len)) { rpc->add(c, "s", cwd_buf); } else { rpc->fault(c, 500, "getcwd Failed"); } pkg_free(cwd_buf); }
static struct mi_root *mi_pwd(struct mi_root *cmd, void *param) { int max_len = 0; char *cwd_buf = 0; struct mi_root *rpl_tree; struct mi_node *rpl; struct mi_node *node; max_len = pathmax(); cwd_buf = pkg_malloc(max_len); if (cwd_buf==NULL) { LM_ERR("no more pkg mem\n"); return NULL; } if (getcwd(cwd_buf, max_len)==0) { LM_ERR("getcwd failed = %s\n",strerror(errno)); pkg_free(cwd_buf); return NULL; } rpl_tree = init_mi_tree( 200, MI_SSTR(MI_OK)); if (rpl_tree==0) { pkg_free(cwd_buf); return NULL; } rpl = &rpl_tree->node; node = add_mi_node_child( rpl, MI_FREE_VALUE, MI_SSTR("WD"), cwd_buf,strlen(cwd_buf)); if (node==0) { LM_ERR("failed to add node\n"); pkg_free(cwd_buf); free_mi_tree(rpl_tree); return NULL; } return rpl_tree; }
static struct mi_root *mi_pwd(struct mi_root *cmd, void *param) { static int max_len = 0; static char *cwd_buf = 0; struct mi_root *rpl_tree; struct mi_node *rpl; struct mi_node *node; if (cwd_buf==NULL) { max_len = pathmax(); cwd_buf = pkg_malloc(max_len); if (cwd_buf==NULL) { LM_ERR("no more pkg mem\n"); return 0; } } rpl_tree = init_mi_tree( 200, MI_SSTR(MI_OK)); if (rpl_tree==0) return 0; rpl = &rpl_tree->node; if (getcwd(cwd_buf, max_len)==0) { LM_ERR("getcwd failed = %s\n",strerror(errno)); goto error; } node = add_mi_node_child( rpl, 0, MI_SSTR("WD"), cwd_buf,strlen(cwd_buf)); if (node==0) { LM_ERR("failed to add node\n"); goto error; } return rpl_tree; error: free_mi_tree(rpl_tree); return 0; }
bool filterlower() { int i,j,w,z; //fprintf(stderr, "AllDiffBounds::filterlower()\n"); for (i=1; i<=nb+1; i++) { d[i] = bounds[i] - bounds[t[i]=h[i]=i-1]; bucket[i] = -1; // this could perhaps be avoided } for (i=0; i<sz; i++) { // visit intervals in increasing max order int minrank = iv[maxsorted[i]].minrank; int maxrank = iv[maxsorted[i]].maxrank; //fprintf(stderr, "var %d [%d, %d)\n", maxsorted[i], bounds[minrank], bounds[maxrank]); j = t[z = pathmax(t, minrank+1)]; iv[maxsorted[i]].next = bucket[z]; bucket[z] = maxsorted[i]; if (--d[z] == 0) t[z = pathmax(t, t[z]=z+1)] = j; pathset(t, minrank+1, z, z); // path compression //if (d[z] < bounds[z]-bounds[maxrank]) return false; // no solution if (h[minrank] > minrank) { Clause* r = NULL; int hall_max = bounds[w = pathmax(h, h[minrank])]; if (so.lazy) { int hall_min = bounds[minrank]; // here both k and hall_min are decreasing, stop when k catches up for (int k = w; bounds[k] > hall_min; --k) for (int l = bucket[k]; l >= 0; l = iv[l].next) hall_min = std::min(hall_min, iv[l].min); //fprintf(stderr, " in hall [%d, %d):\n", hall_min, hall_max); r = Reason_new(2 + (hall_max - hall_min) * 2); (*r)[1] = ~x[maxsorted[i]].getLit(hall_min, 2); int m = 2; for (int k = w; bounds[k] > hall_min; --k) for (int l = bucket[k]; l >= 0; l = iv[l].next) { //fprintf(stderr, " var %d [%d, %d)\n", l, iv[l].min, iv[l].max); (*r)[m++] = ~x[l].getLit(hall_min, 2); (*r)[m++] = ~x[l].getLit(hall_max - 1, 3); } assert(m == 2 + (hall_max - hall_min) * 2); } if (!x[maxsorted[i]].setMin(hall_max, r)) { //fprintf(stderr, " failure\n"); return false; } iv[maxsorted[i]].min = hall_max; if (x[maxsorted[i]].getMin() > hall_max) { //fprintf(stderr, " hole, var %d [%d, %d)\n", maxsorted[i], static_cast<int>(x[maxsorted[i]].getMin()), iv[maxsorted[i]].max); pushInQueue(); // hole in domain } pathset(h, minrank, w, w); // path compression } if (d[z] == bounds[z]-bounds[maxrank]) { //fprintf(stderr, " new hall [%d, %d)\n", bounds[j], bounds[maxrank]); pathset(h, h[maxrank], j-1, maxrank); // mark hall interval h[maxrank] = j-1; } } return true; }
/* returns a pkg_malloc'ed file name */ static char* get_name(struct flat_id* id) { char* buf; int buf_len; char* num, *ptr; int num_len; int total_len; str prefix, suffix; static struct sip_msg flat_dummy_msg; buf_len=pathmax(); if (!id) { LM_ERR("invalid parameter value\n"); return 0; } if (flat_suffix) { if (fixup_get_svalue(&flat_dummy_msg, flat_suffix, &suffix) < 0) { LM_ERR("bad suffix - using default \"%s\"\n", FILE_SUFFIX); suffix.s = FILE_SUFFIX; suffix.len = FILE_SUFFIX_LEN; } } else { suffix.s = 0; suffix.len = 0; } if (flat_prefix) { if (fixup_get_svalue(&flat_dummy_msg, flat_prefix, &prefix) < 0) { LM_ERR("bad prefix - discarding\n"); prefix.s = 0; prefix.len = 0; } } else { prefix.s = 0; prefix.len = 0; } total_len = id->dir.len + 1 /* / */ + prefix.len /* table prefix */ + id->table.len /* table name */ + suffix.len /* table suffix */ + flat_single_file ? 2 : 1 /* _ needed? + '\0' */; /* without pid */ if (buf_len<total_len){ LM_ERR("the path is too long (%d and PATHMAX is %d)\n", total_len, buf_len); return 0; } buf=pkg_malloc(buf_len); if (buf==0){ LM_ERR("pkg memory allocation failure\n"); return 0; } ptr = buf; memcpy(ptr, id->dir.s, id->dir.len); ptr += id->dir.len; *ptr++ = '/'; memcpy(ptr, prefix.s, prefix.len); ptr += prefix.len; memcpy(ptr, id->table.s, id->table.len); ptr += id->table.len; if (!flat_single_file) { *ptr++ = '_'; num = int2str(flat_pid, &num_len); if (buf_len<(total_len+num_len)){ LM_ERR("the path is too long (%d and PATHMAX is" " %d)\n", total_len+num_len, buf_len); pkg_free(buf); return 0; } memcpy(ptr, num, num_len); ptr += num_len; } memcpy(ptr, suffix.s, suffix.len); ptr += suffix.len; *ptr = '\0'; return buf; }