char *find_ip(list_head_t *ip_h, const char *ipaddr) { ip_param *ip; char *slash, *ip_slash, *ip_only; int len; if (list_empty(ip_h)) return NULL; slash = strchr(ipaddr, '/'); if (slash) { len = slash - ipaddr + 1; ip_slash = strndupa(ipaddr, len); ip_only = strndupa(ipaddr, len - 1); } else { ip_only = NULL; len = asprintf(&ip_slash, "%s/", ipaddr); } list_for_each(ip, ip_h, list) { /* Match complete IP or IP/mask string */ if (!strcmp(ip->val, ipaddr)) return ip->val; /* Match only IP */ if ((ip_only != NULL) && (!strcmp(ip->val, ip_only))) return ip->val; /* Match IP/ (same IP, different mask) */ if (!strncmp(ip->val, ip_slash, len)) return ip->val; } return NULL; }
int tc_cmd_env_set(const char *name, uint32_t namelen, const char *value, uint32_t valuelen) { /* Validate the name */ uint32_t i = 0; for (i = 0; i < namelen; i++) { if (!tc_cmd_env_ischar(name[i])) break; } if (i < namelen || namelen == 0) { tc_log(TC_LOG_ERR, "Invalid name for variable \"%s\"", strndupa(name, namelen)); return -1; } /* Replace an existing value if found */ tc_cmd_env_t *e = tc_cmd_env_find(name, namelen); if (e) { free((void *)e->value); e->value = strndup(value, valuelen); tc_log(TC_LOG_INFO, "Variable %s = \"%s\" (replaced value)", strndupa(name, namelen), strndupa(value, valuelen)); return 0; } /* Add the new value if not found */ e = (tc_cmd_env_t *)malloc(sizeof(tc_cmd_env_t)); e->name = strndup(name, namelen); e->value = strndup(value, valuelen); e->next = tc_cmd_env; tc_cmd_env = e; tc_log(TC_LOG_INFO, "Variable %s = \"%s\" (new value)", strndupa(name, namelen), strndupa(value, valuelen)); return 0; }
int show_man_page(const char *desc, bool null_stdio) { const char *args[4] = { "man", NULL, NULL, NULL }; char *e = NULL; pid_t pid; size_t k; int r; siginfo_t status; k = strlen(desc); if (desc[k-1] == ')') e = strrchr(desc, '('); if (e) { char *page = NULL, *section = NULL; page = strndupa(desc, e - desc); section = strndupa(e + 1, desc + k - e - 2); args[1] = section; args[2] = page; } else args[1] = desc; pid = fork(); if (pid < 0) return log_error_errno(errno, "Failed to fork: %m"); if (pid == 0) { /* Child */ (void) reset_all_signal_handlers(); (void) reset_signal_mask(); if (null_stdio) { r = make_null_stdio(); if (r < 0) { log_error_errno(r, "Failed to kill stdio: %m"); _exit(EXIT_FAILURE); } } execvp(args[0], (char**) args); log_error_errno(errno, "Failed to execute man: %m"); _exit(EXIT_FAILURE); } r = wait_for_terminate(pid, &status); if (r < 0) return r; log_debug("Exit code %i status %i", status.si_code, status.si_status); return status.si_status; }
static void mqtt_callback(char* topic, byte* payload, int len) { debug.log("Message arrived [", topic, ']'); for (int i = 0; i < len; i++) { Serial.print((char)payload[i]); } Serial.println(); if (strcmp(topic, mqtt_upgrade_topic) == 0) { if (strlen(VERSION) != len || strncmp((const char*)payload, VERSION, len) != 0) { check_upgrade(); } else { debug.log("Asking to upgrade to our version, not doing anything"); } // Only after we got an upgrade chance we should go to sleep debug.log("MQTT upgrade notification received, sleep lock released"); sleep_postpone(50); return; } char *data = strndupa((char*)payload, len); for (int i = 0; i < NUM_MQTT_SUBS; i++) { if (strcmp(subscription[i].topic, topic) == 0) { subscription[i].callback(data); return; } } }
int main(int argc, char **argv) { static struct gengetopt_args_info args_info; assert(cmdline_parser(argc, argv, &args_info) == 0); char* pattern = args_info.pattern_orig; char* text = read_text(args_info.text_arg); uint32_t n = strlen(text); uint32_t m = strlen(pattern); /* occ[] stores if a position is an occurrence */ uint32_t* occ = calloc(n, sizeof(*occ)); assert(occ != NULL); /* Initialize random number generator */ gsl_rng *rng = gsl_rng_alloc(gsl_rng_mt19937); uint32_t num_rounds = (size_t) args_info.rounds_arg; for (size_t i = 0; i < num_rounds; i++) { uint32_t mod = random_prime(rng); for (size_t j = 0; j < m; j++) for (size_t c = 0; c < 4; c++) corrections[c] = (j == 0) ? c : (corrections[c] << 2) % mod; uint32_t pattern_h = init_h(pattern, m, mod); uint32_t pos = m; for (uint32_t text_h = init_h(text, m, mod); pos < n; text_h = next_h(text_h, text[pos - m], text[pos], mod), pos++) if (pattern_h == text_h) occ[pos - m]++; } for (uint32_t pos = 0; pos < n; pos++) if (occ[pos] >= num_rounds) { char* x = strndupa(text + pos, m); printf("Occurrence %s at position %d\n", x, pos); } free(occ); }
/* on call, propagate it to the dbus service */ static void api_dbus_client_call(struct api_dbus *api, struct afb_req req, struct afb_context *context, const char *verb, size_t lenverb) { size_t size; int rc; char *method = strndupa(verb, lenverb); struct dbus_memo *memo; /* create the recording data */ memo = api_dbus_client_make_memo(req, context); if (memo == NULL) { afb_req_fail(req, "error", "out of memory"); return; } /* makes the call */ rc = sd_bus_call_method_async(api->sdbus, NULL, api->name, api->path, api->name, method, api_dbus_client_on_reply, memo, "ssu", afb_req_raw(req, &size), ctxClientGetUuid(context->session), (uint32_t)context->flags); /* if there was an error report it directly */ if (rc < 0) { errno = -rc; afb_req_fail(req, "error", "dbus error"); api_dbus_client_free_memo(memo); } }
int sol_str_slice_to_int(const struct sol_str_slice s, int *value) { const char *tmp; char *endptr = NULL; long v; if (!s.len) return -EINVAL; tmp = strndupa(s.data, s.len); if (!tmp) return -errno; errno = 0; v = strtol(tmp, &endptr, 0); if (errno) return -errno; if (*endptr != 0) return -EINVAL; if ((long)(int)v != v) return -ERANGE; *value = v; return 0; }
/* * consume 1 line from req->parse_start, and store the header field if necessary */ static int parse_header_line(struct parser *req) { char *str = req->parse_start; static regex_t regex; /* store the match. [0] is the whole string. * [1] is Host|User-agent... [2] is the corresponding value [3] is * useless*/ static regmatch_t match[4]; regcomp(®ex, "^([a-zA-Z_-]+): (([^\r]|\r[^\n])+)\r\n", REG_EXTENDED); int ret = regexec(®ex, str, 4, match, 0); if (ret) return -1; /* store this header */ int i = req->headers_num; if (i >= MAX_HEADER) /* this should not happen in most cases */ return -1; int len = match[1].rm_eo-match[1].rm_so; syslog(LOG_INFO, "got %s", strndupa(str, match[1].rm_eo-match[1].rm_so)); memcpy(req->headers[i].field_name, (str + match[1].rm_so), len); req->headers[i].field_name[len] = '\0'; req->headers[i].value = dup_second_match(str, match); req->headers_num++; /* finish storing header */ req->parse_start += match[0].rm_eo; /* update where next parse should start */ regfree(®ex); return 0; }
/* query a subobject path starting at fsid returning the data in the tail of the path */ static int query_subobj_path(int fsid, int subobj, const char *path, int *len, void *ret[], const int max) { int i=0; int idx = 0; const char *tok, *end; if (max <=0) return 0; end = strchr(path,'/'); tok = (end) ? strndupa(path,end-path) : path; ret[idx] = query_part(fsid, subobj, tok, &len[idx]); if (!ret[idx]) return idx; if (end) { struct mfs_obj_attr *objattr = ret[idx]; int count = (len[idx]-4)/sizeof(*objattr); for (i=0;i<count;i++) { int n; fsid = ntohl(objattr->fsid); subobj = ntohl(objattr->subobj); n = query_subobj_path( fsid, subobj, end+1, len+idx, ret+idx, max-idx ); idx += n; objattr++; } } else idx++; return idx; }
static int sync_dir_of(const char *new_path) { /* Sync destination dir, so dir information is sure to be stored */ char *tmp, *dir_name; int dir_fd; tmp = strndupa(new_path, PATH_MAX); dir_name = dirname(tmp); dir_fd = open(dir_name, O_RDONLY | O_CLOEXEC | O_DIRECTORY); if (dir_fd < 0) { SOL_WRN( "Could not open destination directory to ensure file information is stored: %s", sol_util_strerrora(errno)); return -errno; } errno = 0; if (fsync(dir_fd) < 0) { SOL_WRN("Could not open ensure file information is stored: %s", sol_util_strerrora(errno)); } close(dir_fd); return -errno; }
/** * Create a new buffer with the replaced environment values. * * \param buf Buffer with values to be replaced. * \param len Length of original buffer and output of final. * \return The allocated buffer that should be freed with free. */ static char *tc_cmd_env_subs(const char *buf, uint32_t *len) { uint8_t state = 0; uint32_t l = 0; uint32_t alloc = 0; char *result = NULL; uint32_t i = 0; bool finished = false; while (true) { if (l == alloc) { alloc = alloc ? (alloc << 1) : 16; result = (char *)realloc(result, alloc); } if (i == *len) { finished = true; break; } if (buf[i] == '$') { i++; if (i == *len) { tc_log(TC_LOG_ERR, "Syntax error: $ at end of command"); break; } if (buf[i] != '$') { uint32_t endi; for (endi = i; endi < *len; endi++) if (!tc_cmd_env_ischar(buf[endi])) break; if (endi == i) { tc_log(TC_LOG_ERR, "Syntax error: $ not followed by variable name"); break; } tc_cmd_env_t *env = tc_cmd_env_find(buf + i, endi - i); if (!env) { tc_log(TC_LOG_ERR, "Syntax error: Variable \"%s\" not found", strndupa(buf + i, endi - i)); break; } uint32_t newl = l + strlen(env->value); while (alloc < newl) { alloc = alloc << 1; result = (char *)realloc(result, alloc); } memcpy(result + l, env->value, strlen(env->value)); l = newl; i = endi; continue; } } result[l++] = buf[i++]; } *len = l; if (!finished) { if (result) { free(result); result = NULL; } } return result; }
int socket_address_parse(SocketAddress *a, const char *s) { char *e, *n; unsigned u; int r; assert(a); assert(s); zero(*a); a->type = SOCK_STREAM; if (*s == '[') { /* IPv6 in [x:.....:z]:p notation */ if (!socket_ipv6_is_supported()) { log_warning("Binding to IPv6 address not available since kernel does not support IPv6."); return -EAFNOSUPPORT; } e = strchr(s+1, ']'); if (!e) return -EINVAL; n = strndupa(s+1, e-s-1); errno = 0; if (inet_pton(AF_INET6, n, &a->sockaddr.in6.sin6_addr) <= 0) return errno > 0 ? -errno : -EINVAL; e++; if (*e != ':') return -EINVAL; e++; r = safe_atou(e, &u); if (r < 0) return r; if (u <= 0 || u > 0xFFFF) return -EINVAL; a->sockaddr.in6.sin6_family = AF_INET6; a->sockaddr.in6.sin6_port = htons((uint16_t) u); a->size = sizeof(struct sockaddr_in6); } else if (*s == '/') { /* AF_UNIX socket */ size_t l; l = strlen(s); if (l >= sizeof(a->sockaddr.un.sun_path)) return -EINVAL; a->sockaddr.un.sun_family = AF_UNIX; memcpy(a->sockaddr.un.sun_path, s, l); a->size = offsetof(struct sockaddr_un, sun_path) + l + 1; } else if (*s == '@') {
/* Returns 0 on success and 1 on error */ static int extract_timestamp(const char *b, au_event_t *e) { char *ptr, *tmp; int rc = 1; e->host = NULL; if (*b == 'n') tmp = strndupa(b, 340); else tmp = strndupa(b, 80); ptr = audit_strsplit(tmp); if (ptr) { // Optionally grab the node - may or may not be included if (*ptr == 'n') { e->host = strdup(ptr+5); (void)audit_strsplit(NULL);// Bump along to next one } // at this point we have type= ptr = audit_strsplit(NULL); if (ptr) { if (*(ptr+9) == '(') ptr+=9; else ptr = strchr(ptr, '('); if (ptr) { // now we should be pointed at the timestamp char *eptr; ptr++; eptr = strchr(ptr, ')'); if (eptr) *eptr = 0; if (str2event(ptr, e) == 0) rc = 0; } // else we have a bad line } // else we have a bad line } if (rc) free((void *)e->host); // else we have a bad line return rc; }
int main(int argc, char **argv) { int rc = cib_ok; int timeout = 0; char *client_epoch = getenv("QUERY_STRING"); if (client_epoch && client_epoch[0] == '\0') client_epoch = NULL; if (client_epoch) { char *amp = strchrnul(client_epoch, '&'); if (amp - client_epoch < MAX_EPOCH_LENGTH) { /* * Make a copy of the query string, but without any * possible ampersand and subsequent parameters. This * can be strcmp'd easily later, but allows adding * params to the query string to force the browser not * to cache these requests. */ client_epoch = strndupa(client_epoch, amp - client_epoch); } } origin = getenv("HTTP_ORIGIN"); /* Final arg appeared circa pcmk 1.1.8 */ crm_log_init(NULL, LOG_CRIT, FALSE, FALSE, argc, argv, TRUE); cib = cib_new(); rc = cib_connect(); if (rc != cib_ok && client_epoch == NULL) { /* Client had no epoch, wait to connect */ do { sleep(1); rc = cib_connect(); } while (rc == cib_connection && ++timeout < CONNECT_TIMEOUT); } if (rc == cib_ok) { get_new_epoch(); if (client_epoch != NULL && strcmp(client_epoch, new_epoch) == 0) { /* Wait a while to see if something changes */ mainloop = g_main_loop_new(NULL, FALSE); mainloop_add_signal(SIGTERM, mon_shutdown); mainloop_add_signal(SIGINT, mon_shutdown); g_timeout_add(CONNECT_TIMEOUT * 1000, mon_timer_popped, NULL); g_main_loop_run(mainloop); cleanup(); g_main_loop_unref(mainloop); mainloop = NULL; } } cleanup(); finish(); return 0; /* never reached */ }
/* * This function will look at the line and pick out pieces of it. */ static int extract_timestamp(const char *b, event *e) { char *ptr, *tmp, *tnode, *ttype; e->node = NULL; tmp = strndupa(b, 120); ptr = strtok(tmp, " "); if (ptr) { // Check to see if this is the node info if (*ptr == 'n') { tnode = ptr+5; ptr = strtok(NULL, " "); } else tnode = NULL; // at this point we have type= ttype = ptr+5; // Now should be pointing to msg= ptr = strtok(NULL, " "); if (ptr) { if (*(ptr+9) == '(') ptr+=9; else ptr = strchr(ptr, '('); if (ptr) { // now we should be pointed at the timestamp char *eptr; ptr++; eptr = strchr(ptr, ')'); if (eptr) *eptr = 0; if (str2event(ptr, e)) { fprintf(stderr, "Error extracting time stamp (%s)\n", ptr); return 0; } else if ((start_time && e->sec < start_time) || (end_time && e->sec > end_time)) return 0; else { if (tnode) e->node = strdup(tnode); e->type = audit_name_to_msg_type(ttype); } return 1; } // else we have a bad line } // else we have a bad line } // else we have a bad line return 0; }
static int field_set_test(Set *fields, const char *name, size_t n) { char *s = NULL; if (!fields) return 1; s = strndupa(name, n); if (!s) return log_oom(); return set_get(fields, s) ? 1 : 0; }
static void test_unbase32hexmem_one(const char *hex, bool padding, int retval, const char *ans) { _cleanup_free_ void *mem = NULL; size_t len; assert_se(unbase32hexmem(hex, (size_t) -1, padding, &mem, &len) == retval); if (retval == 0) { char *str; str = strndupa(mem, len); assert_se(streq(str, ans)); } }
int test_and_mkdir(const char *path) { // first, find parent path; const char *ptr = path + strlen(path); while (*ptr != '/' && ptr > path) { ptr--; } char *parent = strndupa(path, ptr - path); // no need to free manually assert(parent != NULL); dmd_log(LOG_DEBUG, "in function %s, parent path is %s\n", __func__, parent); dmd_log(LOG_DEBUG, "in function %s, path is %s\n", __func__, path); if (access(parent, F_OK) == 0) { // parent exist, just mkdir if (access(path, F_OK) == 0) { // path exist, just return dmd_log(LOG_DEBUG, "in function %s, dir %s existed already\n", __func__, path); return 0; } else { // else just mkdir path; if (mkdir(path, 0755) == -1) { dmd_log(LOG_ERR, "in function %s, mkdir %s error:%s\n", __func__, path, strerror(errno)); return -1; } else { dmd_log(LOG_DEBUG, "in function %s, mkdir %s succeed\n", __func__, path); } } } else { // parent doesn't exist, recursively call test_and_mkdir(); // first mkdir parent; int ret = test_and_mkdir(parent); if (ret == -1) { return ret; } // then mkdir path; if (mkdir(path, 0755) == -1) { dmd_log(LOG_ERR, "in function %s, mkdir %s error:%s\n", __func__, path, strerror(errno)); return -1; } else { dmd_log(LOG_DEBUG, "in function %s, mkdir2 %s succeed\n", __func__, path); } } return 0; }
int mkdir_p(const char *path, int len, mode_t mode) { char *start, *end; start = strndupa(path, len); end = start + len; /* * scan backwards, replacing '/' with '\0' while the component doesn't * exist */ for (;;) { int r = is_dir(start); if (r > 0) { end += strlen(end); if (end == start + len) return 0; /* end != start, since it would be caught on the first * iteration */ *end = '/'; break; } else if (r == 0) return -ENOTDIR; if (end == start) break; *end = '\0'; /* Find the next component, backwards, discarding extra '/'*/ while (end > start && *end != '/') end--; while (end > start && *(end - 1) == '/') end--; } for (; end < start + len;) { if (mkdir(start, mode) < 0 && errno != EEXIST) return -errno; end += strlen(end); *end = '/'; } return 0; }
static int ip_ctl(vps_handler *h, envid_t veid, int op, char *str) { const char *ip, *mask; mask = strchr(str, '/'); if (mask) { ip = strndupa(str, mask - str); mask++; } else { ip = str; } return h->ip_ctl(h, veid, op, ip); }
int mkdir_parents_internal(const char *prefix, const char *path, mode_t mode, mkdir_func_t _mkdir) { const char *p, *e; int r; assert(path); assert(_mkdir != mkdir); if (prefix && !path_startswith(path, prefix)) return -ENOTDIR; /* return immediately if directory exists */ e = strrchr(path, '/'); if (!e) return -EINVAL; if (e == path) return 0; p = strndupa(path, e - path); r = is_dir(p, true); if (r > 0) return 0; if (r == 0) return -ENOTDIR; /* create every parent directory in the path, except the last component */ p = path + strspn(path, "/"); for (;;) { char t[strlen(path) + 1]; e = p + strcspn(p, "/"); p = e + strspn(e, "/"); /* Is this the last component? If so, then we're done */ if (*p == 0) return 0; memcpy(t, path, e - path); t[e-path] = 0; if (prefix && path_startswith(prefix, t)) continue; r = _mkdir(t, mode); if (r < 0 && r != -EEXIST) return r; } }
int parse_percent_unbounded(const char *p) { const char *pc, *n; unsigned v; int r; pc = endswith(p, "%"); if (!pc) return -EINVAL; n = strndupa(p, pc - p); r = safe_atou(n, &v); if (r < 0) return r; return (int) v; }
SOL_API unsigned long int sol_util_strtoul_n(const char *nptr, char **endptr, ssize_t len, int base) { char *tmpbuf, *tmpbuf_endptr; unsigned long int r; if (len < 0) len = (ssize_t)strlen(nptr); tmpbuf = strndupa(nptr, len); errno = 0; r = strtoul(tmpbuf, &tmpbuf_endptr, base); if (endptr) *endptr = (char *)nptr + (tmpbuf_endptr - tmpbuf); return r; }
static void test_unhexmem_one(const char *s, size_t l, int retval) { _cleanup_free_ char *hex = NULL; _cleanup_free_ void *mem = NULL; size_t len; assert_se(unhexmem(s, l, &mem, &len) == retval); if (retval == 0) { char *answer; if (l == (size_t) -1) l = strlen(s); assert_se(hex = hexmem(mem, len)); answer = strndupa(strempty(s), l); assert_se(streq(delete_chars(answer, WHITESPACE), hex)); } }
static int resolve_remote(Connection *c) { static const struct addrinfo hints = { .ai_family = AF_UNSPEC, .ai_socktype = SOCK_STREAM, .ai_flags = AI_ADDRCONFIG }; union sockaddr_union sa = {}; const char *node, *service; int r; if (IN_SET(arg_remote_host[0], '/', '@')) { int salen; salen = sockaddr_un_set_path(&sa.un, arg_remote_host); if (salen < 0) { log_error_errno(salen, "Specified address doesn't fit in an AF_UNIX address, refusing: %m"); goto fail; } return connection_start(c, &sa.sa, salen); } service = strrchr(arg_remote_host, ':'); if (service) { node = strndupa(arg_remote_host, service - arg_remote_host); service++; } else { node = arg_remote_host; service = "80"; } log_debug("Looking up address info for %s:%s", node, service); r = sd_resolve_getaddrinfo(c->context->resolve, &c->resolve_query, node, service, &hints, resolve_cb, c); if (r < 0) { log_error_errno(r, "Failed to resolve remote host: %m"); goto fail; } return 0; fail: connection_free(c); return 0; /* ignore errors, continue serving */ }
/** * Load a file to add new commands * * \param path Path of the file with the new commands. * \retval -1 on error (with a log entry). * \retval 1 on file not possible to be read. * \retval 0 on success. */ static int tc_cmd_load(const char *path) { /* Try to open the file */ FILE *f = fopen(path, "rt"); if (!f) { tc_log(TC_LOG_WARN, "Script file \"%s\" not present", path); return 1; } tc_log(TC_LOG_INFO, "Executing script file \"%s\"", path); /* Try to read a line until it finishes */ int result = 0; while (true) { /* Get a new line without carry return */ char buf[256]; char *r = fgets(buf, sizeof(buf), f); if (!r) break; int buf_len = strlen(buf); if (!buf_len) continue; if (buf[buf_len-1] == '\n') { buf[--buf_len] = 0; if (!buf_len) continue; } /* Execute the commands */ tc_log(TC_LOG_INFO, "Command \"%s\"", strndupa(buf, buf_len)); int nr = tc_cmd(buf, buf_len); if (nr) { if (nr < 0) result = -1; break; } } /* Close the file */ fclose(f); /* Return the result */ return result; }
bool decode_primitive_type(const char *parameter, void **value, ffi_type **type) { const char *prefix; prefix = NULL; *value = NULL; *type = NULL; // If a colon exists, then everything before it is a type if (strchr(parameter, ':')) { // Extract the two components. prefix = strndupa(parameter, strchr(parameter, ':') - parameter); parameter = strchr(parameter, ':') + 1; } else { intmax_t n; char *string; // No type was specified, so there are only two possibilities, // If this is a legal number, then it's an int. Otherwise, this is a // string. if (check_parse_long(parameter, &n)) { *type = &ffi_type_sint; *value = malloc(ffi_type_sint.size); memcpy(*value, &n, ffi_type_sint.size); return true; } // This must be a string. *type = &ffi_type_pointer; *value = malloc(ffi_type_pointer.size); string = strdup(parameter); memcpy(*value, &string, ffi_type_pointer.size); return true; } if (decode_type_prefix(prefix, parameter, type, value, NULL) != true) { builtin_warning("parameter decoding failed"); return false; } return true; }
/* create a directory */ int create_directory_at(int dirfd, const char *directory, mode_t mode, int mkparents) { int rc; size_t len, l; char *copy; const char *iter; rc = mkdirat(dirfd, directory, mode); if (!rc || errno != ENOENT) return rc; /* check parent of dest */ iter = strrchr(directory, '/'); len = iter ? (size_t)(iter - directory) : 0; if (!len) return rc; copy = strndupa(directory, len); /* backward loop */ l = len; rc = mkdirat(dirfd, copy, mode); while(rc) { if (errno != ENOENT) return rc; while (l && copy[l] != '/') l--; if (l == 0) return rc; copy[l] = 0; rc = mkdirat(dirfd, copy, mode); } /* forward loop */ while(l < len) { copy[l] = '/'; while (copy[++l]); rc = mkdirat(dirfd, copy, mode); if (rc) return rc; } /* finalize */ return mkdirat(dirfd, directory, mode); }
static void esql_postgresql_setup(Esql *e, const char *addr, const char *user, const char *passwd) { const char *port; char buf[4096]; const char *db; if (e->backend.conn_str && (!addr) && (!user) && (!passwd)) return; /* reconnect attempt */ db = e->database ? e->database : user; port = strchr(addr, ':'); if (port) e->backend.conn_str_len = snprintf(buf, sizeof(buf), "host=%s port=%s dbname=%s user=%s password=%s connect_timeout=5", strndupa(addr, port - addr), port + 1, db, user, passwd); else e->backend.conn_str_len = snprintf(buf, sizeof(buf), "host=%s dbname=%s user=%s password=%s connect_timeout=5", addr, db, user, passwd); e->backend.conn_str = strdup(buf); }
static int uid_from_file_name(const char *filename, uid_t *uid) { const char *p, *e, *u; p = startswith(filename, "core."); if (!p) return -EINVAL; /* Skip the comm field */ p = strchr(p, '.'); if (!p) return -EINVAL; p++; /* Find end up UID */ e = strchr(p, '.'); if (!e) return -EINVAL; u = strndupa(p, e-p); return parse_uid(u, uid); }