unsigned char *get_auth_entry_info( struct listbox_item *item, struct terminal *term ) { int eax; int ecx; int edx; struct string info; if ( item->type != BI_FOLDER && init_string( &info ) ) { add_format_to_string( &info, "%s: " ); add_uri_to_string( &info, &item->udata[3], URI_HTTP_AUTH ); add_format_to_string( &info, "\n%s: " ); if ( item->udata[4] ) { if ( strlen( &item->udata[4] ) <= 511 ) add_bytes_to_string__( &info, &item->udata[4], strlen( &item->udata[4] ) ); else { add_bytes_to_string__( &info, &item->udata[4], 512 ); add_to_string( &info, "..." ); } } else { add_to_string( &info, _( "none", term ) ); } add_format_to_string( &info, "\n%s: %s\n" ); return info.source; } else { } }
static unsigned char * get_auth_entry_info(struct listbox_item *item, struct terminal *term) { struct auth_entry *auth_entry = (struct auth_entry *)item->udata; struct string info; if (item->type == BI_FOLDER) return NULL; if (!init_string(&info)) return NULL; add_format_to_string(&info, "%s: ", _("URL", term)); add_uri_to_string(&info, auth_entry->uri, URI_HTTP_AUTH); add_format_to_string(&info, "\n%s: ", _("Realm", term)); if (auth_entry->realm) { int len = strlen((const char *)auth_entry->realm); int maxlen = 512; /* Max. number of chars displayed for realm. */ if (len < maxlen) add_bytes_to_string(&info, auth_entry->realm, len); else { add_bytes_to_string(&info, auth_entry->realm, maxlen); add_to_string(&info, (const unsigned char *)"..."); } } else { add_to_string(&info, _("none", term)); } add_format_to_string(&info, "\n%s: %s\n", _("State", term), auth_entry->valid ? _("valid", term) : _("invalid", term)); return info.source; }
static void error_reporter(JSContext *ctx, const char *message, JSErrorReport *report) { unsigned char *strict, *exception, *warning, *error; struct string msg; if (!init_string(&msg)) goto reported; strict = JSREPORT_IS_STRICT(report->flags) ? " strict" : ""; exception = JSREPORT_IS_EXCEPTION(report->flags) ? " exception" : ""; warning = JSREPORT_IS_WARNING(report->flags) ? " warning" : ""; error = !report->flags ? " error" : ""; add_format_to_string(&msg, "A client script raised the following%s%s%s%s", strict, exception, warning, error); add_to_string(&msg, ":\n\n"); add_to_string(&msg, message); if (report->linebuf && report->tokenptr) { int pos = report->tokenptr - report->linebuf; add_format_to_string(&msg, "\n\n%s\n.%*s^%*s.", report->linebuf, pos - 2, " ", strlen(report->linebuf) - pos - 1, " "); } alert_smjs_error(msg.source); done_string(&msg); reported: JS_ClearPendingException(ctx); }
static void add_nntp_html_line(struct string *html, struct connection *conn, unsigned char *line) { struct nntp_connection_info *nntp = conn->info; switch (nntp->target) { case NNTP_TARGET_ARTICLE_NUMBER: case NNTP_TARGET_MESSAGE_ID: case NNTP_TARGET_GROUP_MESSAGE_ID: add_html_to_string(html, line, strlen(line)); break; case NNTP_TARGET_ARTICLE_RANGE: case NNTP_TARGET_GROUP: case NNTP_TARGET_GROUPS: { unsigned char *field = line; line = strchr((const char *)line, '\t'); if (!line) field = ""; else *line++ = 0; add_format_to_string(html, "<li value=\"%s\"><a href=\"%s/%s\">", field, struri(conn->uri), field); field = line; line = strchr((const char *)line, '\t'); if (line) *line++ = 0; add_header_to_string(html, field); add_to_string(html, "</a> "); if (line) { field = line; line = strchr((const char *)line, '\t'); if (line) *line++ = 0; add_header_to_string(html, field); } add_to_string(html, "</li>"); break; } case NNTP_TARGET_QUIT: break; } add_char_to_string(html, '\n'); }
static void error_reporter(JSContext *ctx, const char *message, JSErrorReport *report) { struct ecmascript_interpreter *interpreter = JS_GetContextPrivate(ctx); struct session *ses = interpreter->vs->doc_view->session; struct terminal *term; unsigned char *strict, *exception, *warning, *error; struct string msg; assert(interpreter && interpreter->vs && interpreter->vs->doc_view && ses && ses->tab); if_assert_failed goto reported; term = ses->tab->term; #ifdef CONFIG_LEDS set_led_value(ses->status.ecmascript_led, 'J'); #endif if (!get_opt_bool("ecmascript.error_reporting", ses) || !init_string(&msg)) goto reported; strict = JSREPORT_IS_STRICT(report->flags) ? " strict" : ""; exception = JSREPORT_IS_EXCEPTION(report->flags) ? " exception" : ""; warning = JSREPORT_IS_WARNING(report->flags) ? " warning" : ""; error = !report->flags ? " error" : ""; add_format_to_string(&msg, _("A script embedded in the current " "document raised the following%s%s%s%s", term), strict, exception, warning, error); add_to_string(&msg, ":\n\n"); add_to_string(&msg, message); if (report->linebuf && report->tokenptr) { int pos = report->tokenptr - report->linebuf; add_format_to_string(&msg, "\n\n%s\n.%*s^%*s.", report->linebuf, pos - 2, " ", strlen(report->linebuf) - pos - 1, " "); } info_box(term, MSGBOX_FREE_TEXT, N_("JavaScript Error"), ALIGN_CENTER, msg.source); reported: /* Im clu'les. --pasky */ JS_ClearPendingException(ctx); }
/* Returns a connection state. S_OK if all is well. */ static inline struct connection_state list_directory(struct connection *conn, unsigned char *dirpath, struct string *page) { int show_hidden_files = get_opt_bool((const unsigned char *)"protocol.file.show_hidden_files", NULL); struct directory_entry *entries; struct connection_state state; errno = 0; entries = get_directory_entries(dirpath, show_hidden_files); if (!entries) { if (errno) return connection_state_for_errno(errno); return connection_state(S_OUT_OF_MEM); } state = init_directory_listing(page, conn->uri); if (!is_in_state(state, S_OK)) return connection_state(S_OUT_OF_MEM); add_dir_entries(entries, dirpath, page); if (!add_to_string(page, (const unsigned char *)"</pre>\n<hr/>\n</body>\n</html>\n")) { done_string(page); return connection_state(S_OUT_OF_MEM); } return connection_state(S_OK); }
void ReverseGeoLookupThread::run() { if (geo_lookup_data.isEmpty()) return; QNetworkRequest request; QNetworkAccessManager *rgl = new QNetworkAccessManager(); request.setRawHeader("Accept", "text/json"); request.setRawHeader("User-Agent", getUserAgent().toUtf8()); QEventLoop loop; QString apiCall("http://open.mapquestapi.com/nominatim/v1/reverse.php?format=json&accept-language=%1&lat=%2&lon=%3"); Q_FOREACH (const GeoLookupInfo& info, geo_lookup_data ) { request.setUrl(apiCall.arg(uiLanguage(NULL)).arg(info.lat.udeg / 1000000.0).arg(info.lon.udeg / 1000000.0)); QNetworkReply *reply = rgl->get(request); QObject::connect(reply, SIGNAL(finished()), &loop, SLOT(quit())); loop.exec(); QJsonParseError errorObject; QJsonDocument jsonDoc = QJsonDocument::fromJson(reply->readAll(), &errorObject); if (errorObject.error != QJsonParseError::NoError) { qDebug() << errorObject.errorString(); } else { QJsonObject obj = jsonDoc.object(); QJsonObject address = obj.value("address").toObject(); qDebug() << "found country:" << address.value("country").toString(); struct dive_site *ds = get_dive_site_by_uuid(info.uuid); ds->notes = add_to_string(ds->notes, "countrytag: %s", address.value("country").toString().toUtf8().data()); } reply->deleteLater(); }
static int set_python_search_path(void) { struct string new_python_path; unsigned char *old_python_path; int result = -1; if (!init_string(&new_python_path)) return result; if (elinks_home && !add_format_to_string(&new_python_path, "%s%c", elinks_home, DELIM)) goto end; if (!add_to_string(&new_python_path, CONFDIR)) goto end; old_python_path = (unsigned char *) getenv("PYTHONPATH"); if (old_python_path && !add_format_to_string(&new_python_path, "%c%s", DELIM, old_python_path)) goto end; result = env_set("PYTHONPATH", new_python_path.source, -1); end: done_string(&new_python_path); return result; }
/* TODO: Store cookie in data arg. --jonas*/ void accept_cookie_dialog(struct session *ses, void *data) { /* [gettext_accelerator_context(accept_cookie_dialog)] */ struct cookie *cookie = (struct cookie *)cookie_queries.next; struct string string; assert(ses); if (list_empty(cookie_queries) || !init_string(&string)) return; del_from_list(cookie); add_format_to_string(&string, (const char *)_("Do you want to accept a cookie from %s?", ses->tab->term), cookie->server->host); add_to_string(&string, (const unsigned char *)"\n\n"); add_cookie_info_to_string(&string, cookie, ses->tab->term); msg_box(ses->tab->term, NULL, MSGBOX_FREE_TEXT, N_("Accept cookie?"), ALIGN_LEFT, string.source, cookie, 2, MSG_BOX_BUTTON(N_("~Accept"), accept_cookie_in_msg_box, B_ENTER), MSG_BOX_BUTTON(N_("~Reject"), reject_cookie_in_msg_box, B_ESC)); }
/** @relates string */ struct string * add_xnum_to_string(struct string *string, long long xnum) { unsigned char suff[3] = "\0i"; off_t d = -1; /* XXX: I don't completely like the computation of d here. --pasky */ /* Mebi (Mi), 2^20 */ if (xnum >= 1024 * 1024) { suff[0] = 'M'; d = (xnum * (int) 10 / (int) ((int) (1024 * 1024))) % 10; xnum /= 1024*1024; /* Kibi (Ki), 2^10 */ } else if (xnum >= 1024) { suff[0] = 'K'; d = (xnum * (int) 10 / (int) 1024) % 10; xnum /= 1024; } add_long_to_string(string, xnum); if (d != -1) { add_char_to_string(string, '.'); add_long_to_string(string, d); } add_char_to_string(string, ' '); if (suff[0]) add_to_string(string, suff); add_char_to_string(string, 'B'); return string; }
static void parse_dive_gps(char *line, struct membuffer *str, void *_dive) { uint32_t uuid; degrees_t latitude = parse_degrees(line, &line); degrees_t longitude = parse_degrees(line, &line); struct dive *dive = _dive; struct dive_site *ds = get_dive_site_for_dive(dive); if (!ds) { uuid = get_dive_site_uuid_by_gps(latitude, longitude, NULL); if (!uuid) uuid = create_dive_site_with_gps("", latitude, longitude, dive->when); dive->dive_site_uuid = uuid; } else { if (dive_site_has_gps_location(ds) && (ds->latitude.udeg != latitude.udeg || ds->longitude.udeg != longitude.udeg)) { const char *coords = printGPSCoords(latitude.udeg, longitude.udeg); // we have a dive site that already has GPS coordinates ds->notes = add_to_string(ds->notes, translate("gettextFromC", "multiple GPS locations for this dive site; also %s\n"), coords); free((void *)coords); } ds->latitude = latitude; ds->longitude = longitude; } }
/** @relates string */ struct string * add_duration_to_string(struct string *string, long seconds) { unsigned char q[64]; int qlen = 0; if (seconds < 0) seconds = 0; /* Days */ if (seconds >= (24 * 3600)) { ulongcat(q, &qlen, (seconds / (24 * 3600)), 5, 0); q[qlen++] = 'd'; q[qlen++] = ' '; } /* Hours and minutes */ if (seconds >= 3600) { seconds %= (24 * 3600); ulongcat(q, &qlen, (seconds / 3600), 4, 0); q[qlen++] = ':'; ulongcat(q, &qlen, ((seconds / 60) % 60), 2, '0'); } else { /* Only minutes */ ulongcat(q, &qlen, (seconds / 60), 2, 0); } /* Seconds */ q[qlen++] = ':'; ulongcat(q, &qlen, (seconds % 60), 2, '0'); add_to_string(string, q); return string; }
/** First information such as permissions is gathered for each directory entry. * All entries are then sorted. */ static struct directory_entry * get_smb_directory_entries(int dir, struct string *prefix) { struct directory_entry *entries = NULL; int size = 0; struct smbc_dirent *entry; while ((entry = smbc_readdir(dir))) { struct stat st, *stp; struct directory_entry *new_entries; struct string attrib; struct string name; if (!strcmp(entry->name, ".")) continue; new_entries = mem_realloc(entries, (size + 2) * sizeof(*new_entries)); if (!new_entries) continue; entries = new_entries; if (!init_string(&attrib)) { continue; } if (!init_string(&name)) { done_string(&attrib); continue; } add_string_to_string(&name, prefix); add_to_string(&name, entry->name); stp = (smbc_stat(name.source, &st)) ? NULL : &st; stat_type(&attrib, stp); stat_mode(&attrib, stp); stat_links(&attrib, stp); stat_user(&attrib, stp); stat_group(&attrib, stp); stat_size(&attrib, stp); stat_date(&attrib, stp); entries[size].name = stracpy(entry->name); entries[size].attrib = attrib.source; done_string(&name); size++; } smbc_closedir(dir); if (!size) { /* We may have allocated space for entries but added none. */ mem_free_if(entries); return NULL; } qsort(entries, size, sizeof(*entries), compare_dir_entries); memset(&entries[size], 0, sizeof(*entries)); return entries; }
/* Encodes URIs without encoding stuff like fragments and query separators. */ static void encode_file_uri_string(struct string *string, unsigned char *uristring) { int filenamelen = check_whether_file_exists(uristring); encode_uri_string(string, uristring, filenamelen, 0); if (filenamelen > 0) add_to_string(string, uristring + filenamelen); }
static unsigned char * get_nntp_title(struct connection *conn) { struct nntp_connection_info *nntp = conn->info; struct string title; if (!init_string(&title)) return NULL; switch (nntp->target) { case NNTP_TARGET_ARTICLE_RANGE: add_format_to_string(&title, "Articles in the range %ld to %ld", nntp->current_article, nntp->end_article); break; case NNTP_TARGET_ARTICLE_NUMBER: case NNTP_TARGET_MESSAGE_ID: case NNTP_TARGET_GROUP_MESSAGE_ID: { unsigned char *subject; subject = parse_header(conn->cached->head, "Subject", NULL); if (subject) { add_to_string(&title, subject); mem_free(subject); break; } add_format_to_string(&title, "Article "), add_string_to_string(&title, &nntp->message); if (nntp->target == NNTP_TARGET_MESSAGE_ID) break; add_format_to_string(&title, " in "); add_string_to_string(&title, &nntp->group); break; } case NNTP_TARGET_GROUP: add_format_to_string(&title, "Articles in "), add_string_to_string(&title, &nntp->group); break; case NNTP_TARGET_GROUPS: add_format_to_string(&title, "Newsgroups on "), add_uri_to_string(&title, conn->uri, URI_PUBLIC); break; case NNTP_TARGET_QUIT: break; } return title.source; }
struct string * add_shell_quoted_to_string(struct string *string, unsigned char *src, int len) { add_char_to_string(string, '\''); for (; len; len--, ++src) if (*src == '\'') add_to_string(string, (const unsigned char *)"'\\''"); else add_char_to_string(string, *src); add_char_to_string(string, '\''); return string; }
struct string * add_date_to_string(struct string *string, const unsigned char *fmt, const time_t *date) { unsigned char buffer[MAX_STR_LEN]; time_t when_time = date ? *date : time(NULL); struct tm *when_local = localtime(&when_time); if (strftime((char *)buffer, sizeof(buffer), (const char *)fmt, when_local) <= 0) return NULL; return add_to_string(string, buffer); }
void delete_configuration(struct node **head, struct boot_option *to_delete, char *boot_dir) { /* Handle to_delete is the head node */ if (to_delete == (struct boot_option *)(*head)->data) *head = (*head)->next; struct node *current = (*head)->next; struct node *previous = *head; while (current->data) { if ((struct boot_option *)current->data == to_delete) { remove_node(previous); break; } current = current->next; previous = previous->next; } char *image; if (to_delete->image != NULL) { image = NULL; image = add_to_string(image, 3, boot_dir, "/", basename(to_delete->image)); remove(image); free(image); } char *initrd; if (to_delete->initrd != NULL) { initrd = NULL; initrd = add_to_string(initrd, 3, boot_dir, "/", basename(to_delete->initrd)); remove(initrd); free(initrd); } free_boot_option(to_delete); }
static void add_nntp_html_end(struct string *html, struct connection *conn) { struct nntp_connection_info *nntp = conn->info; switch (nntp->target) { case NNTP_TARGET_ARTICLE_NUMBER: case NNTP_TARGET_MESSAGE_ID: case NNTP_TARGET_GROUP_MESSAGE_ID: add_to_string(html, "</pre>"); break; case NNTP_TARGET_ARTICLE_RANGE: case NNTP_TARGET_GROUP: case NNTP_TARGET_GROUPS: add_to_string(html, "</ol>"); break; case NNTP_TARGET_QUIT: break; } add_to_string(html, "\n<hr />\n</body>\n</html>"); }
static void roman(struct string *p, unsigned n) { int i = 0; if (n >= 4000) { add_to_string(p, (const unsigned char *)"---"); return; } if (!n) { add_to_string(p, (const unsigned char *)"o"); return; } while (n) { while (roman_tbl[i].n <= n) { n -= roman_tbl[i].n; add_to_string(p, roman_tbl[i].s); } i++; assertm(!(n && !roman_tbl[i].n), "BUG in roman number convertor"); if_assert_failed break; } }
/* The global Kernel::p method will for each object, directly write * object.inspect() followed by the current output record separator to the * program's standard output and will bypass the Ruby I/O libraries. * * Inspired by Vim we hook into the method and pop up a nice message box so it * can be used to easily debug scripts without dirtying the screen. */ static VALUE erb_stdout_p(int argc, VALUE *argv, VALUE self) { int i; struct string string; struct terminal *term; if (!init_string(&string)) return Qnil; for (i = 0; i < argc; i++) { VALUE substr; unsigned char *ptr; int len; if (i > 0) add_to_string(&string, ", "); substr = rb_inspect(argv[i]); /* The Ruby p() function writes variable number of objects using * the inspect() method, which adds quotes to the strings, so * gently ignore them. */ ptr = RSTRING(substr)->ptr; len = RSTRING(substr)->len; if (*ptr == '"') ptr++, len--; if (ptr[len - 1] == '"') len--; add_bytes_to_string(&string, ptr, len); } term = get_default_terminal(); if (!term) { usrerror("[Ruby] %s", string.source); done_string(&string); return Qnil; } info_box(term, MSGBOX_NO_TEXT_INTL | MSGBOX_FREE_TEXT, N_("Ruby Message"), ALIGN_LEFT, string.source); return Qnil; }
void set_clipboard_text(unsigned char *data) { /* GNU Screen's clipboard */ if (is_gnuscreen()) { struct string str; if (!init_string(&str)) return; add_to_string(&str, "screen -X register . "); add_shell_quoted_to_string(&str, data, strlen(data)); if (str.length) exe(str.source); if (str.source) done_string(&str); } /* TODO: internal clipboard */ }
void set_clipboard_text(unsigned char *data) { /* GNU Screen's clipboard */ if (is_gnuscreen()) { struct string str; if (!init_string(&str)) return; add_to_string(&str, (const unsigned char *)"screen -X register . "); add_shell_quoted_to_string(&str, data, strlen((const char *)data)); if (str.length) exe(str.source); if (str.source) done_string(&str); } /* Shouldn't complain about leaks. */ if (clipboard) free(clipboard); clipboard = (unsigned char *)strdup((const char *)data); }
static void display_entry(const FSP_RDENTRY *fentry, const unsigned char dircolor[]) { struct string string; /* fentry->name is a fixed-size array and is followed by other * members; thus, if the name reported by the server does not * fit in the array, fsplib must either truncate or reject it. * If fsplib truncates the name, it does not document whether * fentry->namlen is the original length or the truncated * length. ELinks therefore ignores fentry->namlen and * instead measures the length on its own. */ const size_t namelen = strlen(fentry->name); if (!init_string(&string)) return; add_format_to_string(&string, "%10d", fentry->size); add_to_string(&string, "\t<a href=\""); /* The result of encode_uri_string does not include '&' or '<' * which could mess up the HTML. */ encode_uri_string(&string, fentry->name, namelen, 0); if (fentry->type == FSP_RDTYPE_DIR) { add_to_string(&string, "/\">"); if (*dircolor) { add_to_string(&string, "<font color=\""); add_to_string(&string, dircolor); add_to_string(&string, "\"><b>"); } add_html_to_string(&string, fentry->name, namelen); if (*dircolor) { add_to_string(&string, "</b></font>"); } } else { add_to_string(&string, "\">"); add_html_to_string(&string, fentry->name, namelen); } add_to_string(&string, "</a>"); puts(string.source); done_string(&string); }
void add_quoted_str_to_string(const char* str, a_boolean add_quotes, string_buffer_ptr bp) { const char* p = str; const char* escapee; if (add_quotes) { add_1_char_to_string('\"', bp); } for (escapee = p + strcspn(p, "\"\\"); *escapee; escapee = p + strcspn(p, "\"\\")) { const char* q = escapee - 1; add_to_string_with_len(p, escapee - p, bp); add_1_char_to_string('\\', bp); add_1_char_to_string(*escapee, bp); p = escapee + 1; } add_to_string(p, bp); if (add_quotes) { add_1_char_to_string('\"', bp); } }
unsigned char *get_formhist_data_info( struct listbox_item *item, struct terminal *term ) { int eax; int edx; struct string info; struct submitted_value *sv; if ( item->type != BI_FOLDER && init_string( &info ) ) { add_format_to_string( &info, "%s: %s" ); add_char_to_string( &info, 10 ); if ( ( *(char*)(item->udata + 20) & 1 ) & 255 ) { add_to_string( &info, _( "Forms are never saved for this URL.", &term[0] ) ); } else { add_to_string( &info, _( "Forms are saved for this URL.", &term[0] ) ); } add_char_to_string( &info, 10 ); sv = &item->udata[3]; if ( item->udata[3] != item->udata[3] ) { do { add_format_to_string( &info, "\n[%8s] " ); add_to_string( &info, sv->name ); add_to_string( &info, " = " ); if ( sv->value && sv->value[0] ) { if ( sv->type != FC_PASSWORD ) add_to_string( &info, sv->value ); else add_to_string( &info, "********" ); } sv = &sv; } while ( sv->next == item->udata[3] ); return info.source; } else { return info.source; } } else { } }
static void smb_directory(int dir, struct string *prefix, struct uri *uri) { struct string buf; struct directory_entry *entries; if (!is_in_state(init_directory_listing(&buf, uri), S_OK)) { smb_error(connection_state(S_OUT_OF_MEM)); } fputs("text/html", header_out); fclose(header_out); entries = get_smb_directory_entries(dir, prefix); add_smb_dir_entries(entries, NULL, &buf); add_to_string(&buf, "</pre><hr/></body></html>\n"); fputs(buf.source, data_out); done_string(&buf); exit(0); }
static void add_cookie_info_to_string(struct string *string, struct cookie *cookie, struct terminal *term) { add_format_to_string(string, "\n%s: %s", _("Name", term), cookie->name); add_format_to_string(string, "\n%s: %s", _("Value", term), cookie->value); add_format_to_string(string, "\n%s: %s", _("Domain", term), cookie->domain); add_format_to_string(string, "\n%s: %s", _("Path", term), cookie->path); if (!cookie->expires) { add_format_to_string(string, "\n%s: ", _("Expires", term)); add_to_string(string, _("at quit time", term)); #ifdef HAVE_STRFTIME } else { add_format_to_string(string, "\n%s: ", _("Expires", term)); add_date_to_string(string, get_opt_str((const unsigned char *)"ui.date_format", NULL), &cookie->expires); #endif } add_format_to_string(string, "\n%s: %s", _("Secure", term), _(cookie->secure ? N_("yes") : N_("no"), term)); }
static void parse_dive_location(char *line, struct membuffer *str, void *_dive) { uint32_t uuid; char *name = get_utf8(str); struct dive *dive = _dive; struct dive_site *ds = get_dive_site_for_dive(dive); if (!ds) { uuid = get_dive_site_uuid_by_name(name, NULL); if (!uuid) uuid = create_dive_site(name, dive->when); dive->dive_site_uuid = uuid; } else { // we already had a dive site linked to the dive if (same_string(ds->name, "")) { ds->name = strdup(name); } else { // and that dive site had a name. that's weird - if our name is different, add it to the notes if (!same_string(ds->name, name)) ds->notes = add_to_string(ds->notes, translate("gettextFromC", "additional name for site: %s\n"), name); } } free(name); }
unsigned char * get_clipboard_text(void) { /* The following support for GNU Screen's clipboard is * disabled for two reasons: * * 1. It does not actually return the string from that * clipboard, but rather causes the clipboard contents to * appear in stdin. get_clipboard_text is normally called * because the user pressed a Paste key in an input field, * so the characters end up being inserted in that field; * but if there are newlines in the clipboard, then the * field may lose focus, in which case the remaining * characters may trigger arbitrary actions in ELinks. * * 2. It pastes from both GNU Screen's clipboard and the ELinks * internal clipboard. Because set_clipboard_text also sets * them both, the same text would typically get pasted twice. * * Users can instead use the GNU Screen key bindings to run the * paste command. This method still suffers from problem 1 but * any user of GNU Screen should know that already. */ #if 0 /* GNU Screen's clipboard */ if (is_gnuscreen()) { struct string str; if (!init_string(&str)) return NULL; add_to_string(&str, (const unsigned char *)"screen -X paste ."); if (str.length) exe(str.source); if (str.source) done_string(&str); } #endif return stracpy(empty_string_or_(clipboard)); }