/** * Prints the ``port'' followed by host address ``ha'' to ``dst''. The string * written to ``dst'' is always NUL-terminated unless ``size'' is zero. If * ``size'' is too small, the string will be truncated. * * @param dst the destination buffer; may be NULL iff ``size'' is zero. * @param port the port number. * @param ha the host address. * @param size the size of ``dst'' in bytes. * * @return The length of the resulting string assuming ``size'' is sufficient. */ size_t host_port_addr_to_string_buf(uint16 port, const host_addr_t ha, char *dst, size_t size) { char port_buf[UINT32_DEC_BUFLEN]; char host_buf[HOST_ADDR_BUFLEN]; size_t n; uint32_to_string_buf(port, port_buf, sizeof port_buf); host_addr_to_string_buf(ha, host_buf, sizeof host_buf); switch (host_addr_net(ha)) { case NET_TYPE_IPV6: n = concat_strings(dst, size, port_buf, ":[", host_buf, "]", (void *) 0); break; case NET_TYPE_IPV4: n = concat_strings(dst, size, port_buf, ":", host_buf, (void *) 0); break; default: n = g_strlcpy(dst, host_buf, size); } return n; }
/* check if directory is writable */ boolean_t directory_is_writable (char *path) { FILE *f; char *s; int fd; #if defined(_WIN32) s = concat_strings(path, "\\ctm.XXXXXX"); /* mingw doesn't have mkstemp */ s = mktemp(s); f = fopen(s, "w"); #else s = concat_strings(path, "/ctm.XXXXXX"); fd = mkstemp(s); if (fd == -1) return FALSE; f = fdopen(fd, "w"); #endif if (f == NULL) { return FALSE; } else { fclose (f); unlink(s); return TRUE; } }
static struct dns_entry * add_dns_entry (struct instance *o, const char *type, const char *value, int priority) { // allocate entry struct dns_entry *entry = malloc(sizeof(*entry)); if (!entry) { goto fail0; } // generate line entry->line = concat_strings(4, type, " ", value, "\n"); if (!entry->line) { goto fail1; } // set info entry->priority = priority; // add to list LinkedList1_Append(&o->entries, &entry->list_node); return entry; fail1: free(entry); fail0: return NULL; }
/* get object file corresponding to src file */ char * get_object_file (char *src) { // bug 2025 // Create .o files in /tmp in case the src dir is not writable. if (!(keep_flag || (ipa == TRUE) || remember_last_phase == P_any_as)) { char *tmp_file = NULL; char *obj_name = change_suffix(src, "o"); string_pair_item_t *p; FOREACH_STRING_PAIR (p, temp_obj_files) { if (strcmp (STRING_PAIR_KEY(p), obj_name) == 0) return STRING_PAIR_VAL(p); } // Create temp file name as in create_temp_file_name. tmp_file = concat_strings(tmpdir, "/cco.XXXXXX"); int fd = mkstemp(tmp_file); if(fd == -1) { error("mkstemp failed for template: %s", tmp_file); return NULL; } close(fd); add_string_pair (temp_obj_files, obj_name, tmp_file); return tmp_file; }
static size_t thex_upload_prepare_xml(char **data_ptr, const struct tth *tth, filesize_t filesize) { struct dime_record *dime; char buf[512]; size_t len, size; unsigned depth; depth = tt_good_depth(filesize); len = concat_strings(buf, sizeof buf, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n" "<!DOCTYPE hashtree S" /* NOTE: HIDE FROM METACONFIG */ "YSTEM \"" THEX_DOCTYPE "\">\r\n" "<hashtree>\r\n" "<file" " size=\"", filesize_to_string(filesize), "\"" " segmentsize=\"" THEX_SEGMENT_SIZE "\"/>\r\n" "<digest" " algorithm=\"" THEX_HASH_ALGO "\"" " outputsize=\"" THEX_HASH_SIZE "\"/>\r\n" "<serializedtree" " depth=\"", uint32_to_string(depth), "\"" " type=\"" THEX_TREE_TYPE "\"" " uri=\"", thex_upload_uuid(tth), "\"/>\r\n" "</hashtree>\r\n", (void *) 0); dime = dime_record_alloc(); dime_record_set_data(dime, buf, len); dime_record_set_type_mime(dime, "text/xml"); size = dime_create_record(dime, data_ptr, TRUE, FALSE); dime_record_free(&dime); return size; }
/* return path and name of phase */ char * get_full_phase_name (phases_t index) { buffer_t tmp; strcpy(tmp, get_phase_dir(index)); if (strlen(tmp) > 0) { strcat(tmp, "/"); } if (sizeof(EXT_EXE) > 1) { strcat(tmp, get_phase_name(index)); return concat_strings (tmp, EXT_EXE); } else { return concat_strings (tmp, get_phase_name(index)); } }
/** * Record a new leak of `size' bytes allocated at `file', line `line'. */ void leak_add(leak_set_t *ls, size_t size, const char *file, int line) { char key[1024]; struct leak_record *lr; bool found; void *v; leak_set_check(ls); g_assert(file); g_assert(line >= 0); concat_strings(key, sizeof key, file, ":", uint64_to_string(line), (void *) 0); found = htable_lookup_extended(ls->places, key, NULL, &v); if (found) { lr = v; lr->size += size; lr->count++; } else { XPMALLOC(lr); lr->size = size; lr->count = 1; htable_insert(ls->places, xstrdup(key), lr); } }
/** * Get the full program path. * * @return a newly allocated string (through halloc()) that points to the * path of the program being run, NULL if we can't compute a suitable path. */ char * file_program_path(const char *argv0) { filestat_t buf; char *file = deconstify_char(argv0); char filepath[MAX_PATH_LEN + 1]; if (is_running_on_mingw() && !is_strsuffix(argv0, (size_t) -1, ".exe")) { concat_strings(filepath, sizeof filepath, argv0, ".exe", NULL_PTR); } else { clamp_strcpy(filepath, sizeof filepath, argv0); } if (-1 == stat(filepath, &buf)) { int saved_errno = errno; file = file_locate_from_path(argv0); if (NULL == file) { errno = saved_errno; s_warning("%s(): could not stat() \"%s\": %m", G_STRFUNC, filepath); return NULL; } } if (file != NULL && file != argv0) return file; /* Allocated by file_locate_from_path() */ return h_strdup(filepath); }
/* Turn list 'excludes' into list of " --excludes=..." strings, all * properly quoted. Caller must free the returned string. */ static char * make_excludes_args (char *const *excludes) { DECLARE_STRINGSBUF (strings); size_t i; char *s, *ret; for (i = 0; excludes[i] != NULL; ++i) { if (asprintf_nowarn (&s, " --exclude=%Q", excludes[i]) == -1) { reply_with_perror ("asprintf"); free_stringslen (strings.argv, strings.size); return NULL; } if (add_string_nodup (&strings, s) == -1) { free (s); return NULL; } } if (end_stringsbuf (&strings) == -1) return NULL; ret = concat_strings (strings.argv); if (!ret) { reply_with_perror ("concat"); free_stringslen (strings.argv, strings.size); return NULL; } free_stringslen (strings.argv, strings.size); return ret; }
extern void append_libraries_to_list (string_list_t *list) { string_item_t *p; for (p = library_dirs->head; p != NULL; p = p->next) { add_string(list, concat_strings("-L", p->name)); } /* * get_phase_dir(P_library) is not in library_dirs because * library_dirs is also used as the search path for the crt file */ if (!option_was_seen(O_L)) { add_string(list, concat_strings("-L", get_phase_dir(P_library))); } }
/** * Search executable within the user's PATH. * * @return full path if found, NULL otherwise. * The returned string is allocated with halloc(). */ char * file_locate_from_path(const char *argv0) { static bool already_done; char *path; char *tok; char filepath[MAX_PATH_LEN + 1]; char *result = NULL; char *ext = ""; if (is_running_on_mingw() && !is_strsuffix(argv0, (size_t) -1, ".exe")) { ext = ".exe"; } if (filepath_basename(argv0) != argv0) { if (!already_done) { s_warning("can't locate \"%s\" in PATH: name contains '%c' already", argv0, strchr(argv0, G_DIR_SEPARATOR) != NULL ? G_DIR_SEPARATOR : '/'); } goto done; } path = getenv("PATH"); if (NULL == path) { if (!already_done) { s_warning("can't locate \"%s\" in PATH: " "no such environment variable", argv0); } goto done; } path = h_strdup(path); tok = strtok(path, G_SEARCHPATH_SEPARATOR_S); while (NULL != tok) { const char *dir = tok; filestat_t buf; if ('\0' == *dir) dir = "."; concat_strings(filepath, sizeof filepath, dir, G_DIR_SEPARATOR_S, argv0, ext, NULL); if (-1 != stat(filepath, &buf)) { if (S_ISREG(buf.st_mode) && -1 != access(filepath, X_OK)) { result = h_strdup(filepath); break; } } tok = strtok(NULL, G_SEARCHPATH_SEPARATOR_S); } hfree(path); done: already_done = TRUE; /* No warning on subsequent invocation */ return result; }
/** * Get special folder path. * * @return pointer to static string, NULL if folder does not exist. */ static const char * get_folder_basepath(enum special_folder which_folder) { char *special_path = NULL; switch (which_folder) { case PRIVLIB_PATH: { static char *pathname; static bool fetched_xdg_data_dirs; if (NULL == pathname && !fetched_xdg_data_dirs) { special_path = getenv("XDG_DATA_DIRS"); fetched_xdg_data_dirs = TRUE; if (special_path != NULL) { if (is_absolute_path(special_path)) { pathname = omalloc(MAX_PATH_LEN); concat_strings(pathname, MAX_PATH_LEN, special_path, G_DIR_SEPARATOR_S, PACKAGE, (void *) 0); } else { s_warning("ignoring environment XDG_DATA_DIRS: " "holds non-absolute path \"%s\"", special_path); } } } special_path = pathname; } break; case NLS_PATH: { static char *pathname; static bool fetched_nlspath; if (NULL == pathname && !fetched_nlspath) { pathname = getenv("NLSPATH"); fetched_nlspath = TRUE; if (pathname != NULL && !is_absolute_path(pathname)) { s_warning("ignoring environment NLSPATH: " "holds non-absolute path \"%s\"", pathname); pathname = NULL; } else { pathname = ostrdup(pathname); } } if (NULL == pathname) pathname = LOCALE_EXP; special_path = pathname; } break; } return special_path; }
/* return path and name of phase */ char * get_full_phase_name (phases_t index) { buffer_t tmp; strcpy(tmp, get_phase_dir(index)); strcat(tmp, "/"); return concat_strings (tmp, get_phase_name(index)); }
/* return language name */ char * get_lang_name (languages_t index) { #if defined(_WIN32) return concat_strings(language_info[index].name[0], ".exe"); #else return language_info[index].name[0]; #endif }
/* return phase name */ char * get_phase_name (phases_t index) { #if defined(_WIN32) return concat_strings(phase_info[index].name, ".exe"); #else return phase_info[index].name; #endif }
/* prefix all phase names with prefix */ void prefix_all_phase_names (mask_t mask, const char *prefix) { phases_t i; for (i = P_NONE; i < P_LAST; i++) { if ((phase_info[i].mask & mask) != 0) phase_info[i].name = concat_strings(prefix, phase_info[i].name); } }
static int EditStringCB(char **value, int *length, void *data) { fonttool_ui *ui = (fonttool_ui *) data; unsigned char c; static int column = 0, row = 0; char *text; int len = *length; text = *value; TableDeselectCell(ui->font_table, row, column); if (len == 1) { /* */ c = text[0]; row = c/16; column = c % 16; if (ui->valid_chars[c]) { TableSelectCell(ui->font_table, row, column); } else { return FALSE; } } if (ui->new_font) { char *buf; buf = copy_string(NULL, "\\f{"); buf = concat_strings(buf, project_get_font_name_by_id(gproject_get_top(gapp->gp), ui->font_id)); buf = concat_strings(buf, "}"); buf = concat_strings(buf, text); xfree(text); text = copy_string(NULL, buf); *value = text; *length = strlen(buf); xfree(buf); ui->new_font = FALSE; } return TRUE; }
/* prefix all phase dirs with path */ void prefix_all_phase_dirs (mask_t mask, char *path) { phases_t i; for (i = P_NONE; i < P_LAST; i++) { if ((phase_info[i].mask & mask) != 0) phase_info[i].dir = concat_strings(path, phase_info[i].dir); } }
void ui_set_streaming_title(const char *title) { lock_ui(); char *buf = concat_strings(title, " - " APP_NAME); if (buf) { gtk_window_set_title(GTK_WINDOW(main_window), buf); free(buf); } unlock_ui(); }
/** * Convert magnet source to a string representation. * * @return A newly allocated string. */ char * magnet_source_to_string(const struct magnet_source *s) { char *url; g_return_val_if_fail(s, NULL); if (s->url) { url = g_strdup(s->url); } else { char *proxies = NULL; const char *host, *prefix; char prefix_buf[256]; char port_buf[16]; if (s->guid) { char guid_buf[GUID_HEX_SIZE + 1]; guid_to_string_buf(s->guid, guid_buf, sizeof guid_buf); concat_strings(prefix_buf, sizeof prefix_buf, "push://", guid_buf, (void *) 0); prefix = prefix_buf; } else { prefix = "http://"; } port_buf[0] = '\0'; if (s->hostname) { host = s->hostname; if (80 != s->port) { str_bprintf(port_buf, sizeof port_buf, ":%u", (unsigned) s->port); } } else if (s->guid) { proxies = proxies_to_string(s->proxies); host = proxies; } else { host = host_addr_port_to_string(s->addr, s->port); } if (s->path) { url = g_strconcat(prefix, host, port_buf, s->path, (void *) 0); } else if (s->sha1) { url = g_strconcat(prefix, host, port_buf, "/uri-res/N2R?", bitprint_to_urn_string(s->sha1, s->tth), (void *) 0); } else { url = g_strconcat(prefix, host, port_buf, "/", (void *) 0); } HFREE_NULL(proxies); } return url; }
value mlgz_gzopen_gen(value name, value mode) { gzFile str; str = gzopen(String_val(name), String_val(mode)) ; if(str==NULL){ if(errno==0) raise_out_of_memory(); else raise_sys_error(concat_strings(String_val(name), strerror(errno))); } return Val_ptr(str); }
/** * Create a Bitzi lookup URL based on the SHA1. * * @return pointer to static data containing the bitzi URL, NULL on error. */ const char * url_for_bitzi_lookup(const struct sha1 *sha1) { static const char base_url[] = "http://bitzi.com/lookup/"; static char buf[sizeof base_url + SHA1_BASE32_SIZE]; g_return_val_if_fail(sha1, NULL); concat_strings(buf, sizeof buf, base_url, sha1_base32(sha1), (void *) 0); return buf; }
static void nodes_gui_update_node_flags(struct node_data *data, gnet_node_flags_t *flags) { gboolean ultra; g_assert(NULL != data); concat_strings(data->flags, sizeof data->flags, "<tt>", guc_node_flags_to_string(flags), "</tt>", (void *) 0); ultra = NODE_P_ULTRA == flags->peermode || NODE_P_G2HUB == flags->peermode; data->fg = &(gtk_widget_get_style(GTK_WIDGET(treeview_nodes)) ->fg[ultra ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE]); }
int main(void) { char s1[98] = "Hello "; char s2[] = "World!\n"; char *p; printf("%s\n", s1); printf("%s", s2); p = concat_strings(s1, s2); printf("%s", s1); printf("%s", s2); printf("%s", p); return (0); }
const char * host_port_to_string(const char *hostname, host_addr_t addr, uint16 port) { static char buf[MAX_HOSTLEN + 32]; if (hostname) { char port_buf[UINT32_DEC_BUFLEN]; uint32_to_string_buf(port, port_buf, sizeof port_buf); concat_strings(buf, sizeof buf, hostname, ":", port_buf, (void *) 0); } else { host_addr_port_to_string_buf(addr, port, buf, sizeof buf); } return buf; }
/* check if directory is writable */ extern boolean directory_is_writable (string path) { FILE *f; string s; s = concat_strings(path, "/ctm.XXXXXX"); s = mktemp(s); f = fopen(s, "w"); if (f == NULL) { return FALSE; } else { fclose (f); unlink(s); return TRUE; } }
/* append all phase dirs with path */ void append_all_phase_dirs (mask_t mask, char *path) { phases_t i; for (i = P_NONE; i < P_LAST; i++) { if ((phase_info[i].mask & mask) != 0) { /* only append if end with preset PHASEPATH */ if (strcmp(phase_info[i].dir + strlen(phase_info[i].dir) - strlen(PHASEPATH), PHASEPATH) == 0) { phase_info[i].dir = concat_strings(phase_info[i].dir, path); } } } }
const char * host_port_to_string(const char *hostname, host_addr_t addr, uint16 port) { buf_t *b = buf_private(G_STRFUNC, MAX_HOSTLEN + HOST_ADDR_PORT_BUFLEN); char *p = buf_data(b); if (hostname != NULL) { char port_buf[UINT32_DEC_BUFLEN]; uint32_to_string_buf(port, port_buf, sizeof port_buf); concat_strings(p, buf_size(b), hostname, ":", port_buf, NULL_PTR); } else { host_addr_port_to_string_buf(addr, port, p, buf_size(b)); } return p; }
char * concat_path (char *d, char *f) { if ((d == NULL) || (strlen (d) == 0) || strcmp(d, "/") == 0) { /* Directory is root, don't return //f */ return concat_strings ("/", f); } else if ((f == NULL) || (strlen (f) == 0)) { /* file is null, return directory portion only */ return d; } else { char *path = (char *) malloc(strlen(d) + strlen(f) + 2); strcpy (path, d); strcat (path, "/"); strcat (path, f); return path; } }
/** * Verifies "data" against "signature". * * @return TRUE if the signature matches. */ bool svn_release_notification_verify(uint32 revision, time_t date, const struct array *signature) { char rev[12], data[64]; struct array input; uint32_to_string_buf(revision, rev, sizeof rev); input.data = (void *) data; input.size = concat_strings(data, sizeof data, "r", rev, "@", uint32_to_string(date), (void *) 0); return verify_signature(svn_release_notify_certificate(), &input, signature); }