static int send_command(int sd, int events, void *discard) { char buf[8192]; int ret; simple_worker *wp; struct kvvec *kvv; ret = read(sd, buf, sizeof(buf)); if (ret == 0) { iobroker_close(iobs, sd); return 0; } if (ret < 0) { printf("main: Failed to read() from fd %d: %s", sd, strerror(errno)); } /* this happens when we're reading from stdin */ buf[--ret] = 0; kvv = kvvec_create(5); wp = wps[wp_index++ % NWPS]; kvvec_addkv(kvv, "job_id", (char *)mkstr("%d", wp->job_index++)); kvvec_addkv_wlen(kvv, "command", sizeof("command") - 1, buf, ret); kvvec_addkv(kvv, "timeout", (char *)mkstr("%d", 10)); printf("Sending kvvec with %d pairs to worker %d\n", kvv->kv_pairs, wp->pid); worker_send_kvvec(wp->sd, kvv); kvvec_destroy(kvv, 0); return 0; }
void TestSerialization::testDeSerializeWideString() { // Test deserialize { std::istringstream is(serializeWideString(teststring2_w), std::ios::binary); UASSERT(deSerializeWideString(is) == teststring2_w); UASSERT(!is.eof()); is.get(); UASSERT(is.eof()); } // Test deserialize an incomplete length specifier { std::istringstream is(mkstr("\x53"), std::ios::binary); EXCEPTION_CHECK(SerializationError, deSerializeWideString(is)); } // Test deserialize a string with an incomplete character { std::istringstream is(mkstr("\x00\x07\0a\0b\0c\0d\0e\0f\0"), std::ios::binary); EXCEPTION_CHECK(SerializationError, deSerializeWideString(is)); } // Test deserialize a string with incomplete data { std::istringstream is(mkstr("\x00\x08\0a\0b\0c\0d\0e\0f"), std::ios::binary); EXCEPTION_CHECK(SerializationError, deSerializeWideString(is)); } }
void TestSerialization::testDeSerializeLongString() { // Test deserialize { std::istringstream is(serializeLongString(teststring2), std::ios::binary); UASSERT(deSerializeLongString(is) == teststring2); UASSERT(!is.eof()); is.get(); UASSERT(is.eof()); } // Test deserialize an incomplete length specifier { std::istringstream is(mkstr("\x53"), std::ios::binary); EXCEPTION_CHECK(SerializationError, deSerializeLongString(is)); } // Test deserialize a string with incomplete data { std::istringstream is(mkstr("\x00\x00\x00\x05 abc"), std::ios::binary); EXCEPTION_CHECK(SerializationError, deSerializeLongString(is)); } // Test deserialize a string with a length too large { std::istringstream is(mkstr("\xFF\xFF\xFF\xFF blah"), std::ios::binary); EXCEPTION_CHECK(SerializationError, deSerializeLongString(is)); } }
tsequence *readseq_next_line(treadseq *rs){ tsequence *ts; int pos; ts = sequence_new(); ts->success = 0; if (adplib_debug>1) printf("rs: success = 0\n"); if (adplib_debug>1) printf("rs: %d\n", rs->start[rs->current]); rs->temp[0] = 0; pos = 0; if (rs->start[rs->current] != 0) { while ((rs->start[rs->current] != '\n') && (rs->start[rs->current] != 0)) rs->temp[pos++] = rs->start[rs->current++]; if (rs->start[rs->current]=='\n') rs->current++; rs->temp[pos] = 0; ts->seq = mkstr(rs->temp); ts->original_seq = mkstr(rs->temp); // remove additional #13 for DOS input files: if ((pos >= 1) && (rs->temp[pos-1] == 13)) rs->temp[pos-1] = 0; // remove additional #13 for DOS input files: if ((pos >= 1) && (rs->temp[pos-1] == 13)) rs->temp[pos-1] = 0; ts->length = ts->original_length = strlen(ts->seq); ts->success = 1; if (adplib_debug>1) printf("rs: success = 1\n"); } return ts; }
/* bbcall - build tree to set _callsite at call site *cp, emit call site data */ static void bbcall(Symbol yycounts, Coordinate* cp, Tree* e) { static Symbol caller; Value v; union coordinate u; Symbol p = genident(STATIC, array(voidptype, 0, 0), GLOBAL); Tree t = *e; defglobal(p, LIT); defpointer(cp->file ? mkstr(cp->file)->u.c.loc : (Symbol)0); defpointer(mkstr(cfunc->name)->u.c.loc); if (IR->little_endian) { u.le.x = cp->x; u.le.y = cp->y; } else { u.be.x = cp->x; u.be.y = cp->y; } (*IR->defconst)(U, unsignedtype->size, (v.u = u.coord, v)); if (caller == 0) { caller = mksymbol(EXTERN, "_caller", ptr(voidptype)); caller->defined = 0; } if (generic((*e)->op) != CALL) t = (*e)->kids[0]; assert(generic(t->op) == CALL); t = tree(t->op, t->type, tree(RIGHT, t->kids[0]->type, t->kids[0], tree(RIGHT, t->kids[0]->type, asgn(caller, idtree(p)), t->kids[0])), t->kids[1]); if (generic((*e)->op) != CALL) t = tree((*e)->op, (*e)->type, t, (*e)->kids[1]); *e = t; }
void tokenizer_exec(ttokenizer *t, char *name, char *s) { int i; char in_quotes; char *ttoken; char septoken[] = {1,0}; // free old token strings: for (i=0; i < t->count; i++) free(t->token[i]); // build new token array: t->count = 1; // replace whitespaces: in_quotes = 0; for (i=0; i<strlen(s); i++) { if (!in_quotes && (s[i] == ' ')) s[i] = 1; if (s[i] == 39) { in_quotes = 1-in_quotes; s[i] = 1; } } // build token list: t->token[0] = mkstr(name); while((ttoken = strtok(s,septoken))) { t->token[t->count++] = mkstr(ttoken); s = NULL; } // debug output: /* if (debug) { */ /* printf("#token: %d\n", t->count-1); */ /* for (i=1;i<t->count;i++) printf("%s\n", t->token[i]); */ }
/* * Handles adding the command and macros to the kvvec, * as well as shipping the command off to a designated * worker */ static int wproc_run_job(worker_job *job, nagios_macros *mac) { static struct kvvec kvv = KVVEC_INITIALIZER; worker_process *wp; /* * get_worker() also adds job to the workers list * and sets job_id */ wp = get_worker(job); if (!wp || job->id < 0) return ERROR; /* * XXX FIXME: add environment macros as * kvvec_addkv(kvv, "env", "NAGIOS_LALAMACRO=VALUE"); * kvvec_addkv(kvv, "env", "NAGIOS_LALAMACRO2=VALUE"); * so workers know to add them to environment. For now, * we don't support that though. */ if (!kvvec_init(&kvv, 4)) /* job_id, type, command and timeout */ return ERROR; kvvec_addkv(&kvv, "job_id", (char *)mkstr("%d", job->id)); kvvec_addkv(&kvv, "type", (char *)mkstr("%d", job->type)); kvvec_addkv(&kvv, "command", job->command); kvvec_addkv(&kvv, "timeout", (char *)mkstr("%u", job->timeout)); send_kvvec(wp->sd, &kvv); wp->jobs_running++; wp->jobs_started++; return 0; }
char *create_mpispawn_vars(char *mpispawn_env) { char *tmp = NULL; #ifdef CR_FTB /* Keep mpispawn happy. Pass some junk value */ tmp = mkstr("%s MPISPAWN_MPIRUN_CR_PORT=%d", mpispawn_env, 0); #else tmp = mkstr("%s MPISPAWN_MPIRUN_CR_PORT=%d", mpispawn_env, mpirun_port); #endif if (tmp) { free(mpispawn_env); mpispawn_env = tmp; } else { PRINT_ERROR("[1] mkstr() failed\n"); goto allocation_error; } // TODO Should be useless, MPISPAWN_CR_CKPT_CNT should be enough // Remove this in the future int restart_context = 0; if ( restart_version >= 0 ) restart_context = 1; tmp = mkstr("%s MPISPAWN_CR_CONTEXT=%d", mpispawn_env, restart_context); if (tmp) { free(mpispawn_env); mpispawn_env = tmp; } else { PRINT_ERROR("[2] mkstr() failed\n"); goto allocation_error; } tmp = mkstr("%s MPISPAWN_CR_SESSIONID=%s", mpispawn_env, sessionid); if (tmp) { free(mpispawn_env); mpispawn_env = tmp; } else { PRINT_ERROR("[3] mkstr() failed\n"); goto allocation_error; } tmp = mkstr("%s MPISPAWN_CR_CKPT_CNT=%d", mpispawn_env, restart_version); if (tmp) { free(mpispawn_env); mpispawn_env = tmp; } else { PRINT_ERROR("[4] mkstr() failed\n"); goto allocation_error; } return tmp; allocation_error: if (mpispawn_env) { PRINT_ERROR("Error: current mpispawn_env = '%s'\n", mpispawn_env); free(mpispawn_env); } exit(EXIT_FAILURE); }
struct fxp_names *fxp_readdir_recv(struct sftp_packet *pktin, struct sftp_request *req) { sfree(req); if (pktin->type == SSH_FXP_NAME) { struct fxp_names *ret; unsigned long i; i = get_uint32(pktin); /* * Sanity-check the number of names. Minimum is obviously * zero. Maximum is the remaining space in the packet * divided by the very minimum length of a name, which is * 12 bytes (4 for an empty filename, 4 for an empty * longname, 4 for a set of attribute flags indicating that * no other attributes are supplied). */ if (get_err(pktin) || i > get_avail(pktin) / 12) { fxp_internal_error("malformed FXP_NAME packet"); sftp_pkt_free(pktin); return NULL; } /* * Ensure the implicit multiplication in the snewn() call * doesn't suffer integer overflow and cause us to malloc * too little space. */ if (i > INT_MAX / sizeof(struct fxp_name)) { fxp_internal_error("unreasonably large FXP_NAME packet"); sftp_pkt_free(pktin); return NULL; } ret = snew(struct fxp_names); ret->nnames = i; ret->names = snewn(ret->nnames, struct fxp_name); for (i = 0; i < (unsigned long)ret->nnames; i++) { ret->names[i].filename = mkstr(get_string(pktin)); ret->names[i].longname = mkstr(get_string(pktin)); get_fxp_attrs(pktin, &ret->names[i].attrs); } if (get_err(pktin)) { fxp_internal_error("malformed FXP_NAME packet"); for (i = 0; i < (unsigned long)ret->nnames; i++) { sfree(ret->names[i].filename); sfree(ret->names[i].longname); } sfree(ret->names); sfree(ret); sfree(pktin); return NULL; } sftp_pkt_free(pktin); return ret; } else {
/* * Handles adding the command and macros to the kvvec, * as well as shipping the command off to a designated * worker */ static int wproc_run_job(struct wproc_job *job, nagios_macros *mac) { static struct kvvec kvv = KVVEC_INITIALIZER; struct kvvec_buf *kvvb; struct kvvec *env_kvvp = NULL; struct kvvec_buf *env_kvvb = NULL; struct wproc_worker *wp; int ret, result = OK; if (!job || !job->wp) return ERROR; wp = job->wp; if (!kvvec_init(&kvv, 4)) /* job_id, type, command and timeout */ return ERROR; kvvec_addkv(&kvv, "job_id", (char *)mkstr("%d", job->id)); kvvec_addkv(&kvv, "type", (char *)mkstr("%d", job->type)); kvvec_addkv(&kvv, "command", job->command); kvvec_addkv(&kvv, "timeout", (char *)mkstr("%u", job->timeout)); /* Add the macro environment variables */ if(mac) { env_kvvp = macros_to_kvv(mac); if(NULL != env_kvvp) { env_kvvb = kvvec2buf(env_kvvp, '=', '\n', 0); if(NULL == env_kvvb) { kvvec_destroy(env_kvvp, KVVEC_FREE_KEYS); } else { kvvec_addkv_wlen(&kvv, "env", strlen("env"), env_kvvb->buf, env_kvvb->buflen); } } } kvvb = build_kvvec_buf(&kvv); ret = write(wp->sd, kvvb->buf, kvvb->bufsize); if (ret != (int)kvvb->bufsize) { logit(NSLOG_RUNTIME_ERROR, TRUE, "wproc: '%s' seems to be choked. ret = %d; bufsize = %lu: errno = %d (%s)\n", wp->name, ret, kvvb->bufsize, errno, strerror(errno)); destroy_job(job); result = ERROR; } else { wp->jobs_running++; wp->jobs_started++; loadctl.jobs_running++; } if(NULL != env_kvvp) kvvec_destroy(env_kvvp, KVVEC_FREE_KEYS); if(NULL != env_kvvb) { free(env_kvvb->buf); free(env_kvvb); } free(kvvb->buf); free(kvvb); return result; }
std::string CInitializer::GetDefaultsXmlFile() { std::string fzdatadir = mkstr(getenv("FZ_DATADIR")); std::string file = CheckPathForDefaults(fzdatadir, 0, "fzdefaults.xml"); if (!file.empty()) return file; file = CheckPathForDefaults(fzdatadir, 1, "fzdefaults.xml"); if (!file.empty()) return file; std::string home = mkstr(getenv("HOME")); if (!home.empty()) { if (home[home.size() - 1] != '/') home += '/'; home += ".filezilla/fzdefaults.xml"; struct stat buf; if (!stat(home.c_str(), &buf)) return home; } file = "/etc/filezilla/fzdefaults.xml"; struct stat buf; if (!stat(file.c_str(), &buf)) return file; file = CheckPathForDefaults(mkstr(SELFPATH), 2, "share/filezilla/fzdefaults.xml"); if (!file.empty()) return file; file = CheckPathForDefaults(mkstr(DATADIR), 0, "filezilla/fzdefaults.xml"); if (!file.empty()) return file; std::string path = mkstr(getenv("PATH")); while (!path.empty()) { std::string segment; int pos = path.find(':'); if (pos == -1) segment.swap(path); else { segment = path.substr(0, pos); path = path.substr(pos + 1); } file = CheckPathForDefaults(segment, 1, "share/filezilla/fzdefaults.xml"); if (!file.empty()) return file; } return ""; }
static int parse_uri(const char *proxystr, struct uri *uri) { const char *p, *q; /* Scheme, section 3.1. */ p = proxystr; if (!isalpha(*p)) goto fail; q = p; while (isalpha(*q) || isdigit(*q) || *q == '+' || *q == '-' || *q == '.') q++; if (*q != ':') goto fail; uri->scheme = mkstr(p, q); /* "An implementation should accept uppercase letters as equivalent to * lowercase in scheme names (e.g., allow "HTTP" as well as "http") for the * sake of robustness..." */ lowercase(uri->scheme); /* Authority, section 3.2. */ p = q + 1; if (*p == '/' && *(p + 1) == '/') { char *authority = NULL; p += 2; q = p; while (!(*q == '/' || *q == '?' || *q == '#' || *q == '\0')) q++; ; authority = mkstr(p, q); if (uri_parse_authority(authority, uri) < 0) { free(authority); goto fail; } free(authority); p = q; } /* Path, section 3.3. We include the query and fragment in the path. The * path is also not percent-decoded because we just pass it on to the origin * server. */ q = strchr(p, '\0'); uri->path = mkstr(p, q); return 1; fail: uri_free(uri); return -1; }
void TestSerialization::testSerializeString() { // Test blank string UASSERT(serializeString("") == mkstr("\0\0")); // Test basic string UASSERT(serializeString("Hello world!") == mkstr("\0\14Hello world!")); // Test character range UASSERT(serializeString(teststring2) == mkstr("\1\0") + teststring2); }
int uri_parse(const char *uri_s, struct uri *uri) { const char *p, *q; uri_init(uri); /* Scheme, section 3.1. */ p = uri_s; if (!is_alpha_char(*p)) goto fail; q = p; while (is_alpha_char(*q) || is_digit_char(*q) || *q == '+' || *q == '-' || *q == '.') q++; if (*q != ':') goto fail; uri->scheme = mkstr(p, q); lowercase(uri->scheme); /* Authority, section 3.2. */ p = q + 1; if (*p == '/' && *(p + 1) == '/') { char *authority = NULL; p += 2; q = p; while (!(*q == '/' || *q == '?' || *q == '#' || *q == '\0')) q++; authority = mkstr(p, q); if (uri_parse_authority(uri, authority)) { free(authority); goto fail; } free(authority); p = q; } q = strchr(p, '\0'); uri->path = mkstr(p, q); return 0; fail: uri_free(uri); return -EINVAL; }
/* Parse a URI string into a struct URI. Any parts of the URI that are absent will become NULL entries in the structure, except for the port which will be -1. Returns NULL on error. See RFC 3986, section 3 for syntax. */ struct uri *uri_parse(struct uri *uri, const char *uri_s) { const char *p, *q; uri_init(uri); /* Scheme, section 3.1. */ p = uri_s; if (!is_alpha_char(*p)) goto fail; for (q = p; is_alpha_char(*q) || is_digit_char(*q) || *q == '+' || *q == '-' || *q == '.'; q++) ; if (*q != ':') goto fail; uri->scheme = mkstr(p, q); /* "An implementation should accept uppercase letters as equivalent to lowercase in scheme names (e.g., allow "HTTP" as well as "http") for the sake of robustness..." */ lowercase(uri->scheme); /* Authority, section 3.2. */ p = q + 1; if (*p == '/' && *(p + 1) == '/') { char *authority = NULL; p += 2; for (q = p; !(*q == '/' || *q == '?' || *q == '#' || *q == '\0'); q++) ; authority = mkstr(p, q); if (uri_parse_authority(uri, authority) == NULL) { free(authority); goto fail; } free(authority); p = q; } if (uri->port == -1) uri->port = scheme_default_port(uri->scheme); /* Path, section 3.3. We include the query and fragment in the path. The path is also not percent-decoded because we just pass it on to the origin server. */ q = strchr(p, '\0'); uri->path = mkstr(p, q); return uri; fail: uri_free(uri); return NULL; }
void TestSerialization::testSerializeWideString() { // Test blank string UASSERT(serializeWideString(L"") == mkstr("\0\0")); // Test basic string UASSERT(serializeWideString(utf8_to_wide("Hello world!")) == mkstr("\0\14\0H\0e\0l\0l\0o\0 \0w\0o\0r\0l\0d\0!")); // Test character range UASSERT(serializeWideString(teststring2_w) == mkstr("\1\0") + teststring2_w_encoded); }
static char * ps(const char *m, const char *s, size_t len) { char *d, *s1, *s2, *s3; s1 = mkstr(m, len); s2 = mkstr(s, len); s3 = concat(s1, s2); free(s2); free(s1); d = concat("(.?)", s3); free(s3); return d; }
static char * p6(size_t len) { char *d, *s1, *s2; s1 = mkstr("(?:(.*)|", len); s2 = concat(s1, "(.*)"); free(s1); s1 = mkstr(")", len); d = concat(s2, s1); free(s1); free(s2); return d; }
static List *extractsinglematch(const char *subject, const char *pattern, const char *quoting, List *result) { int i; const char *s; if (!haswild(pattern, quoting) /* no wildcards, so no matches */ || !match(subject, pattern, quoting)) return NULL; for (s = subject, i = 0; pattern[i] != '\0'; s++) { if (ISQUOTED(quoting, i)) i++; else { int c = pattern[i++]; switch (c) { case '*': { const char *begin; if (pattern[i] == '\0') return mklist(mkstr(gcdup(s)), result); for (begin = s;; s++) { const char *q = TAILQUOTE(quoting, i); assert(*s != '\0'); if (match(s, pattern + i, q)) { result = mklist(mkstr(gcndup(begin, s - begin)), result); return haswild(pattern + i, q) ? extractsinglematch(s, pattern + i, q, result) : result; } } } case '[': { int j = rangematch(pattern + i, TAILQUOTE(quoting, i), *s); assert(j != RANGE_FAIL); if (j == RANGE_ERROR) { assert(*s == '['); break; } i += j; } /* FALLTHROUGH */ case '?': result = mklist(mkstr(str("%c", *s)), result); break; default: break; } } } return result; }
static char * p1(size_t len) { char *d, *s1, *s2, *s3; s1 = mkstr("\\(", 60); s2 = mkstr("(.*)", len); s3 = concat(s1, s2); free(s2); free(s1); s1 = concat(s3, ")"); free(s3); d = concat("(", s1); free(s1); return d; }
/*static*/ void gl::printGLError (GLenum errorCode) { if (errorCode == GL_NO_ERROR) return; std::string errorString = ""; if (errorCode == GL_INVALID_ENUM) errorString = "GL_INVALID_ENUM: An unacceptable value is specified for an enumerated argument."; else if (errorCode == GL_INVALID_VALUE) errorString = "GL_INVALID_VALUE: A numeric argument is out of range."; else if (errorCode == GL_INVALID_OPERATION) errorString = "GL_INVALID_OPERATION: The specified operation is not allowed in the current state."; else if (errorCode == GL_INVALID_FRAMEBUFFER_OPERATION) errorString = "GL_INVALID_FRAMEBUFFER_OPERATION: The framebuffer object is not complete."; else if (errorCode == GL_OUT_OF_MEMORY) errorString = "GL_OUT_OF_MEMORY: There is not enough memory left to execute the command."; else errorString = "Unknown internal error."; log::println_err (mkstr ("OpenGL reported an error: (", (unsigned) errorCode, ") ", errorString)); }
std::string CInitializer::GetSettingFromFile(std::string file, const std::string& name) { TiXmlDocument xmldoc; if (!xmldoc.LoadFile(file.c_str())) return ""; TiXmlElement* main = xmldoc.FirstChildElement("FileZilla3"); if (!main) return ""; TiXmlElement* settings = main->FirstChildElement("Settings"); if (!settings) return ""; for (TiXmlElement* setting = settings->FirstChildElement("Setting"); setting; setting = setting->NextSiblingElement("Setting")) { const char* nodeVal = setting->Attribute("name"); if (!nodeVal || strcmp(nodeVal, name.c_str())) continue; TiXmlNode* textNode = setting->FirstChild(); if (!textNode || !textNode->ToText()) continue; return mkstr(textNode->Value()); } return ""; }
void YouBotOODLWrapper::initializeBase() { try { youBotBase = new youbot::YouBotBase("youbot-base", mkstr(YOUBOT_CONFIGURATIONS_DIR)); youBotBase->doJointCommutation(); // } catch (youbot::FileNotFoundException& e) { } catch (std::exception& e) { std::string errorMessage = e.what(); ROS_FATAL("Cannot open youBot driver: \n %s ", errorMessage.c_str()); ROS_ERROR("Base could not be initialized!"); hasBase = false; return; } /* setup input/output communication */ baseCommandSubscriber = node.subscribe("cmd_vel", 1000, &YouBotOODLWrapper::baseCommandCallback, this); baseOdometryPublisher = node.advertise<nav_msgs::Odometry>("odom", 1); baseJointStatePublisher = node.advertise<sensor_msgs::JointState>("base_joint_states", 1); /* setup frame_ids */ youBotOdometryFrameID = "odom"; youBotOdometryChildFrameID = "base_footprint"; ROS_INFO("Base is initialized."); hasBase = true; }
char *fxp_realpath_recv(struct sftp_packet *pktin, struct sftp_request *req) { sfree(req); if (pktin->type == SSH_FXP_NAME) { unsigned long count; char *path; ptrlen name; count = get_uint32(pktin); if (get_err(pktin) || count != 1) { fxp_internal_error("REALPATH did not return name count of 1\n"); sftp_pkt_free(pktin); return NULL; } name = get_string(pktin); if (get_err(pktin)) { fxp_internal_error("REALPATH returned malformed FXP_NAME\n"); sftp_pkt_free(pktin); return NULL; } path = mkstr(name); sftp_pkt_free(pktin); return path; } else { fxp_got_status(pktin); sftp_pkt_free(pktin); return NULL; } }
/* glob -- globbing prepass (glob if we need to, and dispatch for tilde expansion) */ extern List *glob(List *list, StrList *quote) { List *lp; StrList *qp; Boolean doglobbing = FALSE; for (lp = list, qp = quote; lp != NULL; lp = lp->next, qp = qp->next) if (qp->str != QUOTED) { assert(lp->term != NULL); assert(!isclosure(lp->term)); Ref(char *, str, getstr(lp->term)); assert(qp->str == UNQUOTED || strlen(qp->str) == strlen(str)); if (hastilde(str, qp->str)) { Ref(List *, l0, list); Ref(List *, lr, lp); Ref(StrList *, q0, quote); Ref(StrList *, qr, qp); str = expandhome(str, qp); lr->term = mkstr(str); lp = lr; qp = qr; list = l0; quote = q0; RefEnd4(qr, q0, lr, l0); } if (haswild(str, qp->str)) doglobbing = TRUE; RefEnd(str); }
static ChanopenResult chan_open_direct_tcpip( struct ssh2_connection_state *s, SshChannel *sc, ptrlen dstaddr, int dstport, ptrlen peeraddr, int peerport) { PacketProtocolLayer *ppl = &s->ppl; /* for ppl_logevent */ Channel *ch; char *dstaddr_str, *err; dstaddr_str = mkstr(dstaddr); ppl_logevent("Received request to connect to port %s:%d (from %.*s:%d)", dstaddr_str, dstport, PTRLEN_PRINTF(peeraddr), peerport); err = portfwdmgr_connect( s->portfwdmgr, &ch, dstaddr_str, dstport, sc, ADDRTYPE_UNSPEC); sfree(dstaddr_str); if (err != NULL) { ppl_logevent("Port open failed: %s", err); sfree(err); CHANOPEN_RETURN_FAILURE( SSH2_OPEN_CONNECT_FAILED, ("Connection failed")); } ppl_logevent("Port opened successfully"); CHANOPEN_RETURN_SUCCESS(ch); }
bool_t delchar(bool_t fixpos, bool_t undo) /* bool_t fixpos; /* if TRUE fix the cursor position when done */ /* bool_t undo; /* if TRUE put char deleted into Undo buffer */ { int i; /* Check for degenerate case; there's nothing in the file. */ if (bufempty()) return FALSE; if (lineempty(Curschar)) /* can't do anything */ return FALSE; if (undo) AppendToUndobuff(mkstr(gchar(Curschar))); /* Delete the char. at Curschar by shifting everything in the line down. */ for (i = Curschar->index + 1; i < Curschar->linep->size; i++) Curschar->linep->s[i - 1] = Curschar->linep->s[i]; /* * If we just took off the last character of a non-blank line, we don't * want to end up positioned at the newline. */ if (fixpos) { if (gchar(Curschar) == NUL && Curschar->index > 0 && State != INSERT) Curschar->index--; } CHANGED; return TRUE; }
/* Returns 0 on success and nonzero on failure. */ int http_parse_status_line(const char *line, struct http_response *response) { const char *p, *q; http_response_init(response); /* Version. */ p = parse_http_version(line, &response->version); if (p == line) return -1; while (*p == ' ') p++; /* Status code. */ errno = 0; response->code = parse_long(p, (char **) &q); if (errno != 0 || q == p) return -1; p = q; /* Reason phrase. */ while (*p == ' ') p++; q = p; while (!is_crlf(q)) q++; /* We expect that the CRLF ends the string. */ if (*skip_crlf(q) != '\0') return -1; response->phrase = mkstr(p, q); return 0; }
/* create a new format string entry */ static tformat_string *format_string_newentry(char type, char *string){ tformat_string *f; f = (tformat_string *) mcalloc(1, sizeof(tformat_string)); f->type = type; f->string = mkstr(string); f->next = NULL; return f; }
tsequence *readseq_next_fasta(treadseq *rs){ tsequence *ts; int pos; char inpc,fil; ts = sequence_new(); rs->temp[0] = 0; pos = 0; if ((rs->start[rs->current] == '>') && (rs->start[rs->current] != 0)) { if (!rs->first_descr_read && rs->first_input_read) { fprintf(stderr, "error in input file: missing description for first sequence\n"); exit(1); } rs->first_descr_read = 1; rs->current++; while ((rs->start[rs->current] != '\n') && (rs->start[rs->current] != 0)) rs->temp[pos++] = rs->start[rs->current++]; if (rs->start[rs->current]) rs->current++; } rs->temp[pos] = 0; ts->descr = mkstr(rs->temp); // remove additional #13 for DOS input files: if ((pos >= 1) && (rs->temp[pos-1] == 13)) rs->temp[pos-1] = 0; rs->temp[0] = 0; pos = 0; fil = 1; while ((fil || (rs->start[rs->current] != '>')) && (rs->start[rs->current] != 0)) { while (((inpc = rs->start[rs->current]) != '\n') && (rs->start[rs->current] != 0)) if (((inpc >= 65) && (inpc <= 90)) || ((inpc >= 97) && (inpc <= 122))) rs->temp[pos++] = rs->start[rs->current++]; else rs->current++; fil = 0; if (rs->start[rs->current]) rs->current++; rs->first_input_read = 1; } rs->temp[pos] = 0; ts->seq = mkstr(rs->temp); ts->original_seq = mkstr(rs->temp); ts->length = ts->original_length = strlen(ts->seq); if (ts->seq[0]) ts->success = 1; else ts->success = 0; return ts; }