/** Parse data into a linked list of blobs.
*/
struct Blob* parse_all_blobs(struct Parser* const p) {
struct Blob* b = 0;
struct Blob* last = 0;
b = parse_blob(p); //parse a first
for( last=b;
p->cur - p->data < p->len;
last=last->next ) {
last->next = parse_blob(p);
if (last->next == 0)
break;
}
return b;
}
struct object *parse_object(unsigned char *sha1)
{
unsigned long mapsize;
void *map = map_sha1_file(sha1, &mapsize);
if (map) {
char type[100];
unsigned long size;
void *buffer = unpack_sha1_file(map, mapsize, type, &size);
if (!buffer)
return NULL;
if (check_sha1_signature(sha1, buffer, size, type) < 0)
printf("sha1 mismatch %s\n", sha1_to_hex(sha1));
munmap(map, mapsize);
if (!strcmp(type, "blob")) {
struct blob *ret = lookup_blob(sha1);
parse_blob(ret);
return &ret->object;
} else if (!strcmp(type, "tree")) {
struct tree *ret = lookup_tree(sha1);
parse_tree(ret);
return &ret->object;
} else if (!strcmp(type, "commit")) {
struct commit *ret = lookup_commit(sha1);
parse_commit(ret);
return &ret->object;
} else if (!strcmp(type, "tag")) {
struct tag *ret = lookup_tag(sha1);
parse_tag(ret);
return &ret->object;
} else {
return NULL;
}
}
return NULL;
}
Value *Parser::parse_value(void) {
int c;
Value *value;
c = read_byte();
switch (c) {
case trace::TYPE_NULL:
value = new Null;
break;
case trace::TYPE_FALSE:
value = new Bool(false);
break;
case trace::TYPE_TRUE:
value = new Bool(true);
break;
case trace::TYPE_SINT:
value = parse_sint();
break;
case trace::TYPE_UINT:
value = parse_uint();
break;
case trace::TYPE_FLOAT:
value = parse_float();
break;
case trace::TYPE_DOUBLE:
value = parse_double();
break;
case trace::TYPE_STRING:
value = parse_string();
break;
case trace::TYPE_ENUM:
value = parse_enum();
break;
case trace::TYPE_BITMASK:
value = parse_bitmask();
break;
case trace::TYPE_ARRAY:
value = parse_array();
break;
case trace::TYPE_STRUCT:
value = parse_struct();
break;
case trace::TYPE_BLOB:
value = parse_blob();
break;
case trace::TYPE_OPAQUE:
value = parse_opaque();
break;
default:
std::cerr << "error: unknown type " << c << "\n";
exit(1);
case -1:
value = NULL;
break;
}
#if TRACE_VERBOSE
if (value) {
std::cerr << "\tVALUE " << value << "\n";
}
#endif
return value;
}
static void
pro_message_available (PROFILE_INSTANCE *pi) {
int result,
size;
char *buffer,
*payload,
*response;
FRAME *f;
struct configobj *appconfig = bp_get_config (pi -> channel -> conn);
PRO_LOCALDATA *il = (PRO_LOCALDATA *) pi -> user_ptr1;
result = SASL_ALREADY_DONE;
if (!(f = bpc_query_message (pi -> channel, BLU_QUERY_ANYTYPE,
BLU_QUERY_ANYMSG, BLU_QUERY_ANYANS)))
return;
if (pro_debug) {
fprintf (stderr,
"%s message_available: type=%c number=%ld answer=%ld size=%ld\n",
pro_name (pi -> channel -> profile_registration -> uri),
f -> msg_type, f -> message_number, f -> answer_number,
f -> size);
fprintf (stderr, f -> size > 150 ? "%-150.150s...\n" : "%s\n",
f -> payload);
fflush (stderr);
}
size = bpc_frame_aggregate (pi -> channel, f, &buffer);
if (buffer == NULL) {
bp_log (pi -> channel -> conn, LOG_PROF, 5,
"%s message_available: out of memory aggregating message",
pro_name (pi -> channel -> profile_registration -> uri));
bpc_frame_destroy (pi -> channel, f);
return;
}
switch (il -> pl_task) {
case PRO_CLIENT_ANON:
break;
case PRO_CLIENT_OTP:
if (il -> pl_sent != 2)
break;
if (strstr (buffer, "<error") != NULL)
sasl_error (pi, buffer, size);
else {
parse_blob (buffer, &il -> pl_sdb);
if (!strcmp (il -> pl_sdb.parse_blob_status, "complete"))
sasl_set_local_success (pi);
else
sasl_set_local_failure (pi, NULL);
}
break;
case PRO_SERVER_ANON:
if (il -> pl_sent != 0)
break;
if ((result = sasl_anonymous_server_guts (buffer, &il -> pl_sdb))
== SASL_COMPLETE)
config_set (appconfig, SASL_REMOTE_USERNAME,
il -> pl_sdb.parse_blob_data);
break;
case PRO_SERVER_OTP:
switch (il -> pl_sent) {
case 0:
result = sasl_otp_server_guts_1 (buffer, &il -> pl_sdb);
break;
case 1:
if ((result = sasl_otp_server_guts_2 (buffer, &il -> pl_sdb))
== SASL_COMPLETE) {
config_set (appconfig, SASL_REMOTE_USERNAME,
il -> pl_sdb.authenID);
config_set (appconfig, SASL_REMOTE_TARGET,
(il -> pl_sdb.authorID[0] != '\0')
? il -> pl_sdb.authorID
: il -> pl_sdb.authenID);
}
break;
}
break;
}
bpc_buffer_destroy (pi -> channel, buffer);
switch (il -> pl_task) {
case PRO_CLIENT_ANON:
case PRO_CLIENT_OTP:
response = NULL;
break;
case PRO_SERVER_ANON:
case PRO_SERVER_OTP:
response = sasl_response (pi, result);
break;
}
if (f -> msg_type == BLU_FRAME_TYPE_MSG) {
payload = response ? response
: "<error code='521'>Client-side only</error>";
size = strlen (payload) + sizeof DEFAULT_CONTENT_TYPE - 1;
if ((buffer = bpc_buffer_allocate(pi -> channel, size)) != NULL) {
sprintf (buffer, "%s%s", DEFAULT_CONTENT_TYPE, payload);
bpc_send (pi -> channel,
(payload[1] == 'e')
? BLU_FRAME_TYPE_ERR : BLU_FRAME_TYPE_RPY,
f -> message_number, f -> answer_number,
BLU_FRAME_COMPLETE, buffer, size);
il -> pl_sent++;
} else
bp_log (pi -> channel -> conn, LOG_PROF, 5,
"%s message: out of memory sending response",
pro_name (pi -> channel -> profile_registration -> uri));
}
bpc_frame_destroy (pi -> channel, f);
}
static void
pro_start_confirmation (void *clientData,
PROFILE_INSTANCE *pi,
PROFILE *po) {
int problem,
size;
char *buffer,
*payload;
PRO_LOCALDATA *il = clientData;
struct configobj *appconfig = bp_get_config (pi -> channel -> conn);
if (pro_debug) {
fprintf (stderr, "%s start_confirmation: piggyback=\"%s\"\n",
pro_name (po -> uri),
po -> piggyback ? po -> piggyback : "<NULL>");
fflush (stderr);
}
pi -> user_ptr1 = il;
il -> pl_flags &= ~(PRO_STARTING | PRO_CLOSED);
il -> pl_channel = pi -> channel;
if (po -> piggyback_length == 0) {
il -> pl_status = bp_diagnostic_new (pi -> channel -> conn, 504, NULL,
"expecting blob element");
return;
}
if (strstr (po -> piggyback, "<error")) {
sasl_error (pi, po -> piggyback, po -> piggyback_length);
return;
}
switch (il -> pl_task) {
case PRO_CLIENT_ANON:
parse_blob (po -> piggyback, &il -> pl_sdb);
if (!strcmp (il -> pl_sdb.parse_blob_status, "complete"))
sasl_set_local_success (pi);
else
sasl_set_local_failure (pi, NULL);
break;
case PRO_CLIENT_OTP:
if (!(payload = sasl_otp_client_guts_2
(po -> piggyback,
config_get (appconfig, SASL_LOCAL_PASSPHRASE),
&problem, &il -> pl_sdb))) {
if (problem == SASL_ERROR_ALGORITHM) {
config_set (appconfig, SASL_LOCAL_CODE, "504");
config_set (appconfig, SASL_LOCAL_REASON,
"unsupported algorithm");
} else {
config_set (appconfig, SASL_LOCAL_CODE, "501");
config_set (appconfig, SASL_LOCAL_REASON,
"unable to parse blob");
}
payload = "<blob status='abort' />";
}
size = strlen (payload) + sizeof DEFAULT_CONTENT_TYPE - 1;
if ((buffer = bpc_buffer_allocate (pi -> channel, size)) != NULL) {
sprintf (buffer, "%s%s", DEFAULT_CONTENT_TYPE, payload);
bpc_send (pi -> channel, BLU_FRAME_TYPE_MSG,
BLU_FRAME_MSGNO_UNUSED, BLU_FRAME_IGNORE_ANSNO,
BLU_FRAME_COMPLETE, buffer, size);
il -> pl_sent++;
} else
bp_log (pi -> channel -> conn, LOG_PROF, 5,
"%s start_confirmation: out of memory",
pro_name (po -> uri));
break;
}
}
std::vector<std::string *> SQL_ROW::parse_row(std::string &s) {
// parses a SQL row of the format "value,value,value,value",
// where value can be of the form:
// number (i.e. 10)
// "string"
// 'string'
// LIST{value,value,value}
// ROW(value,value,value)::typename
// the passed string is consumed by this routine.
// WARNING: NOT THREAD SAFE
std::string::size_type comma,dquote,quote,p;
std::vector<std::string *>::iterator i;
std::vector<std::string *> rv;
static bool outer=true;
while (s.size()) { // While there's still bits of string left to process
// get rid of leading spaces and commas
while (isspace(s[0]) && s.size()) s.erase(0,1);
while (s[0]==',') s.erase(0,1);
// Handle the special cases first...
if (s.find("LIST")==0) {
// only parse a LIST if the entire string passed to parse_row was a list
if (outer) {
outer=false;
std::vector<std::string *> tmprow(parse_list(s));
for (i=tmprow.begin();i<tmprow.end();i++) {
rv.push_back(*i);
}
} else {
rv.push_back(string_delimited(s,'L','}'));
}
} else if (s.find("ROW")==0) {
// only parse a LIST if the entire string passed to parse_row was a ROW
// type
if (outer) {
outer=false;
std::vector<std::string *> tmprow(parse_type(s));
for (i=tmprow.begin();i<tmprow.end();i++) {
rv.push_back(*i);
}
} else {
rv.push_back(string_delimited(s,'R',')'));
}
} else if (s.find("<BYTE")==0) {
rv.push_back(parse_blob(s));
} else {
// now for the non-special cases... We need to find the delimiting
// commas for the item at the head of the line...
comma=s.find(',');
// but beware that the item we're parsing might be a string
quote=s.find('\'');
dquote=s.find('\"');
p=std::min(std::min(comma,quote),dquote);
// if we found none of the above, we're done.
if (!found(p)) {
rv.push_back(new std::string(s));
#ifdef DEBUG_ALLOCATIONS
fprintf(stderr,"std::string allocated at 0x%p\n",rv[rv.size()-1]);
fflush(stderr);
#endif
s.erase();
} else {
switch (s[p]) {
case ',': // if we found a comma, this is a non quoted entry
rv.push_back(new std::string(s,0,p));
#ifdef DEBUG_ALLOCATIONS
fprintf(stderr,"std::string allocated at 0x%p\n",rv[rv.size()-1]);
fflush(stderr);
#endif
s.erase(0,p+1);
break;
case '\'': // if we found a quote we need to find the close quote
quote=s.find('\'',p+1);
if (found(quote)) {
// if we found it, use the quoted entity
rv.push_back(new std::string(s,p+1,quote-p-1));
#ifdef DEBUG_ALLOCATIONS
fprintf(stderr,"std::string allocated at 0x%p\n",rv[rv.size()-1]);
fflush(stderr);
#endif
s.erase(0,quote+2); // Assume that the character after our quote is
// our comma.
} else {
// if we didn't find it, we guess that everything up to the next
// comma is OK.
rv.push_back(new std::string(s,0,comma));
#ifdef DEBUG_ALLOCATIONS
fprintf(stderr,"std::string allocated at 0x%p\n",rv[rv.size()-1]);
fflush(stderr);
#endif
s.erase(0,comma+1);
}
break;
case '\"': // if we found a dquote we need to find the close quote
dquote=s.find('\"',p+1);
if (found(dquote)) {
// if we found it, use the quoted entity
rv.push_back(new std::string(s,p+1,dquote-p-1));
#ifdef DEBUG_ALLOCATIONS
fprintf(stderr,"std::string allocated at 0x%p\n",rv[rv.size()-1]);
fflush(stderr);
#endif
s.erase(0,dquote+2); // Assume that the character after our quote is
// our comma.
} else {
// if we didn't find it, we guess that everything up to the next
// comma is OK.
rv.push_back(new std::string(s,0,comma));
#ifdef DEBUG_ALLOCATIONS
fprintf(stderr,"std::string allocated at 0x%p\n",rv[rv.size()-1]);
fflush(stderr);
#endif
s.erase(0,comma+1);
}
break;
default:
// this should never happen
abort();
}
}
}
outer=false;
}
outer=true;
return rv;
}
