GList *get_list_from_buffer(gchar *buffer, GList *which_list, gboolean is_arraylist) {
gchar *pos,*nextpos;
pos = buffer;
nextpos = strchr(pos, '\n');
do {
if (nextpos)
*nextpos='\0';
/*g_print("next line: %s\n",pos);*/
if (is_arraylist) {
gchar **temparr = string_to_array(pos);
which_list = g_list_prepend(which_list, temparr);
} else {
DEBUG_MSG("get_list, adding string \"%s\" to the stringlist=%p\n", pos, which_list);
which_list = g_list_prepend(which_list, g_strdup(pos));
}
if (nextpos) {
nextpos++;
if (*nextpos == '\0')
pos = NULL;
else
pos = nextpos;
} else
pos = NULL;
if (pos)
nextpos = strchr(pos, '\n');
} while (pos);
return g_list_reverse(which_list);
}
NODE* string_to_tree_converter(char *input_array)
{
int *integer_array = string_to_array(input_array);
integer_array = Quick_Sort(integer_array,0,array_length(integer_array)-1);
NODE* output = array_to_tree_convertor(integer_array,0,array_length(integer_array));
free(integer_array);
return output;
}
void test_tree_construction()
{
char inorder[5][36] = { "8,4,9,2,10,5,11,1,12,6,13,3,14,7,15",
"1,2,3,4",
"1,2,3",
"1,2,3,4,5,6,7,8,9,10,11,12,13,14,15",
"1,2"
};
char preorder[5][36] = { "1,2,4,8,9,5,10,11,3,6,12,13,7,14,15",
"2,1,3,4",
"2,1,3",
"8,4,2,1,3,6,5,7,12,10,9,11,14,13,15",
"1,2"
};
char expected_tree[5][52] = {"1,2,4,8,$,9,$,5,10,$,11,$,3,6,12,$,13,$,7,14,$,15,$",
"2,1,$,3,-,4,$",
"2,1,$,3,$",
"8,4,2,1,$,3,$,6,5,$,7,$,12,10,9,$,11,$,14,13,$,15,$",
"1,-,2,$"
};
int iter_loop;
for(iter_loop=0;iter_loop<5;iter_loop++)
{
printf("%d-->",iter_loop+1);
int preorder_index = 0;
int *inorder_array = string_to_array(inorder[iter_loop]);
int *preorder_array = string_to_array(preorder[iter_loop]);
NODE *head = construct_tree_from_inorder_preorder(inorder_array,preorder_array,0,array_length(inorder_array)-1,&preorder_index);
NODE *root = (NODE*)malloc(sizeof(NODE));
int index;
index = next_element_in_string(expected_tree[iter_loop],0);
root->data = create_number(expected_tree[iter_loop],index);
index = next_element_in_string(expected_tree[iter_loop],index);
construct_tree(root,expected_tree[iter_loop],index);
(1==tree_comparator(head,root))?printf("ACCEPTED\n"):printf("REJECTED\n");
delete_tree(head);
free(inorder_array);
free(preorder_array);
}
}
//// read a file contents from either a archive of real directory
void b_zzip_read(task *tsk, pntr *argstack)
{
char *fileName;
pntr p = argstack[0];
int badtype;
CHECK_ARG(0, CELL_CONS);
if((badtype = array_to_string(p, &fileName)) >= 0){
set_error(tsk, "error1: argument is not a string (contains non-char: %s)", cell_types[badtype]);
return;
}
ZZIP_FILE* fp = zzip_open (fileName, O_RDONLY|O_BINARY);
if (! fp){
perror (fileName);
}
int bufSize = 2, blockSize = 1024, numBlocks = 1;
char buf[bufSize];
int n, counter = 0;
char *contents = (char *)calloc(blockSize, sizeof(char));
/* read chunks of bufSize bytes into buf and concatenate them into previous string */
while( (n = (zzip_read(fp, buf, bufSize-1))) > 0){
counter++;
if(counter == 1){
// strcpy(contents, buf);
strncat(contents, buf, bufSize-1);
bufSize = 21;
}else{
int originalSize = strlen(contents);
if( ((blockSize*numBlocks) - (originalSize + 1)) < bufSize){
numBlocks++;
contents = string_mkroom(contents, blockSize*numBlocks);
}
strncat(contents, buf, bufSize-1);
// printf("%s\n\n\n", contents);
}
buf[n] = '\0';
}
argstack[0] = string_to_array(tsk, contents);
zzip_close(fp);
}
pntr decode_java_response(task *tsk, const char *str, endpointid source)
{
int len = strlen(str);
if ((2 <= len) && ('"' == str[0]) && ('"' == str[len-1])) {
char *sub = substring(str,1,len-1);
char *unescaped = unescape(sub);
pntr p = string_to_array(tsk,unescaped);
free(unescaped);
free(sub);
return p;
}
else if (!strcmp(str,"nil")) {
return tsk->globnilpntr;
}
else if (!strcmp(str,"false")) {
return tsk->globnilpntr;
}
else if (!strcmp(str,"true")) {
return tsk->globtruepntr;
}
else if ((1 < len) && ('@' == str[0])) {
int id = atoi(str+1);
sysobject *so = new_sysobject(tsk,SYSOBJECT_JAVA);
pntr p;
so->jid.managerid = source;
so->jid.jid = id;
make_pntr(p,so->c);
return p;
}
else if (!strncmp(str,"error: ",7)) {
set_error(tsk,"jcall: %s",&str[7]);
return tsk->globnilpntr;
}
else {
char *end = NULL;
double d = strtod(str,&end);
if (('\0' != *str) && ('\0' == *end)) {
pntr p;
set_pntrdouble(p,d);
return p;
}
else {
set_error(tsk,"jcall: invalid response");
return tsk->globnilpntr;
}
}
}
/*
* parse a buffer.
*
* NOTE: parse() should not be called recusively by any other functions!
*/
void
parse(struct Client *client_p, char *pbuffer, char *bufend)
{
struct Client *from = client_p;
char *ch;
char *s;
char *end;
int i;
int paramcount, mpara = 0;
char *numeric = 0;
struct Message *mptr;
Debug((DEBUG_DEBUG, "Parsing %s:", pbuffer));
s_assert(!IsDead(client_p));
s_assert(client_p->localClient->fd >= 0);
if(IsDead(client_p) || client_p->localClient->fd < 0)
return;
s_assert(bufend-pbuffer < 512);
for (ch = pbuffer; *ch == ' '; ch++) /* skip spaces */
/* null statement */ ;
para[0] = from->name;
if(*ch == ':')
{
ch++;
/*
* Copy the prefix to 'sender' assuming it terminates
* with SPACE (or NULL, which is an error, though).
*/
sender = ch;
if((s = strchr(ch, ' ')))
{
*s = '\0';
s++;
ch = s;
}
i = 0;
if(*sender && IsServer(client_p))
{
from = find_client(sender);
if(from == NULL)
{
from = find_server(sender);
}
/* Hmm! If the client corresponding to the
* prefix is not found--what is the correct
* action??? Now, I will ignore the message
* (old IRC just let it through as if the
* prefix just wasn't there...) --msa
*/
if(from == NULL)
{
Debug((DEBUG_ERROR, "Unknown prefix (%s)(%s) from (%s)",
sender, pbuffer, client_p->name));
ServerStats->is_unpf++;
remove_unknown(client_p, sender, pbuffer);
return;
}
para[0] = from->name;
if(from->from != client_p)
{
ServerStats->is_wrdi++;
Debug((DEBUG_ERROR, "Message (%s) coming from (%s)",
pbuffer, client_p->name));
cancel_clients(client_p, from, pbuffer);
return;
}
}
while (*ch == ' ')
ch++;
}
if(*ch == '\0')
{
ServerStats->is_empt++;
Debug((DEBUG_NOTICE, "Empty message from host %s:%s", client_p->name, from->name));
return;
}
/*
* Extract the command code from the packet. Point s to the end
* of the command code and calculate the length using pointer
* arithmetic. Note: only need length for numerics and *all*
* numerics must have parameters and thus a space after the command
* code. -avalon
*/
/* EOB is 3 chars long but is not a numeric */
if(*(ch + 3) == ' ' && /* ok, lets see if its a possible numeric.. */
IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
{
mptr = (struct Message *) NULL;
numeric = ch;
paramcount = MAXPARA;
ServerStats->is_num++;
s = ch + 3; /* I know this is ' ' from above if */
*s++ = '\0'; /* blow away the ' ', and point s to next part */
}
else
{
int ii = 0;
if((s = strchr(ch, ' ')))
*s++ = '\0';
mptr = hash_parse(ch);
if(!mptr || !mptr->cmd)
{
/*
* Note: Give error message *only* to recognized
* persons. It's a nightmare situation to have
* two programs sending "Unknown command"'s or
* equivalent to each other at full blast....
* If it has got to person state, it at least
* seems to be well behaving. Perhaps this message
* should never be generated, though... --msa
* Hm, when is the buffer empty -- if a command
* code has been found ?? -Armin
*/
if(pbuffer[0] != '\0')
{
if(IsPerson(from))
sendto_one(from,
":%s %d %s %s :Unknown command",
me.name, ERR_UNKNOWNCOMMAND, from->name, ch);
Debug((DEBUG_ERROR, "Unknown (%s) from %s",
ch, get_client_name(client_p, HIDE_IP)));
}
ServerStats->is_unco++;
return;
}
paramcount = mptr->parameters;
mpara = mptr->maxpara;
ii = bufend - ((s) ? s : ch);
mptr->bytes += ii;
}
end = bufend - 1;
/* XXX this should be done before parse() is called */
if(*end == '\n')
*end-- = '\0';
if(*end == '\r')
*end = '\0';
i = 0;
if(s != NULL)
i = string_to_array(s, para);
if(mptr == (struct Message *) NULL)
{
do_numeric(numeric, client_p, from, i, para);
return;
}
if(handle_command(mptr, client_p, from, i, para) < -1)
{
char *p;
for (p = pbuffer; p <= end; p += 8)
{
/* HACK HACK */
/* Its expected this nasty code can be removed
* or rewritten later if still needed.
*/
if((unsigned long) (p + 8) > (unsigned long) end)
{
for (; p <= end; p++)
{
ilog(L_CRIT, "%02x |%c", p[0], p[0]);
}
}
else
ilog(L_CRIT,
"%02x %02x %02x %02x %02x %02x %02x %02x |%c%c%c%c%c%c%c%c",
p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
}
}
}
/*
* parse a buffer.
*
* NOTE: parse() should not be called recusively by any other functions!
*/
void
parse(struct Client *client_p, char *pbuffer, char *bufend)
{
struct Client *from = client_p;
char *ch;
char *s;
char *numeric = 0;
unsigned int i = 0;
struct Message *mptr = NULL;
if (IsDefunct(client_p))
return;
assert(client_p->localClient->fd.flags.open);
assert((bufend - pbuffer) < 512);
for (ch = pbuffer; *ch == ' '; ch++) /* skip spaces */
/* null statement */ ;
para[0] = from->name;
if (*ch == ':')
{
ch++;
/* Copy the prefix to 'sender' assuming it terminates
* with SPACE (or NULL, which is an error, though).
*/
sender = ch;
if ((s = strchr(ch, ' ')) != NULL)
{
*s = '\0';
s++;
ch = s;
}
if (*sender && IsServer(client_p))
{
/*
* XXX it could be useful to know which of these occurs most frequently.
* the ID check should always come first, though, since it is so easy.
*/
if ((from = find_person(client_p, sender)) == NULL)
{
from = find_server(sender);
if (from == NULL && IsCapable(client_p, CAP_TS6) &&
client_p->name[0] == '*' && IsDigit(*sender) && strlen(sender) == 3)
{
/* Dirty hack to allow messages from masked SIDs (i.e. the ones
* hidden by fakename="..."). It shouldn't break anything, since
* unknown SIDs don't happen during normal ircd work --adx
*/
from = client_p;
}
}
/* Hmm! If the client corresponding to the
* prefix is not found--what is the correct
* action??? Now, I will ignore the message
* (old IRC just let it through as if the
* prefix just wasn't there...) --msa
*/
if (from == NULL)
{
ServerStats->is_unpf++;
remove_unknown(client_p, sender, pbuffer);
return;
}
para[0] = from->name;
if (from->from != client_p)
{
ServerStats->is_wrdi++;
cancel_clients(client_p, from, pbuffer);
return;
}
}
while (*ch == ' ')
ch++;
}
if (*ch == '\0')
{
ServerStats->is_empt++;
return;
}
/* Extract the command code from the packet. Point s to the end
* of the command code and calculate the length using pointer
* arithmetic. Note: only need length for numerics and *all*
* numerics must have parameters and thus a space after the command
* code. -avalon
*/
/* EOB is 3 chars long but is not a numeric */
if (*(ch + 3) == ' ' && /* ok, lets see if its a possible numeric.. */
IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
{
mptr = NULL;
numeric = ch;
ServerStats->is_num++;
s = ch + 3; /* I know this is ' ' from above if */
*s++ = '\0'; /* blow away the ' ', and point s to next part */
}
else
{
int ii = 0;
if ((s = strchr(ch, ' ')) != NULL)
*s++ = '\0';
if ((mptr = find_command(ch)) == NULL)
{
/* Note: Give error message *only* to recognized
* persons. It's a nightmare situation to have
* two programs sending "Unknown command"'s or
* equivalent to each other at full blast....
* If it has got to person state, it at least
* seems to be well behaving. Perhaps this message
* should never be generated, though... --msa
* Hm, when is the buffer empty -- if a command
* code has been found ?? -Armin
*/
if (pbuffer[0] != '\0')
{
if (IsClient(from))
sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
me.name, from->name, ch);
}
ServerStats->is_unco++;
return;
}
assert(mptr->cmd != NULL);
ii = bufend - ((s) ? s : ch);
mptr->bytes += ii;
}
if (s != NULL)
i = string_to_array(s, para);
else
{
i = 0;
para[1] = NULL;
}
if (mptr == NULL)
do_numeric(numeric, client_p, from, i, para);
else
handle_command(mptr, client_p, from, i, para);
}
static gboolean parse_config_file(GList * config_list, gchar * filename)
{
gboolean retval = FALSE;
gchar *tmpstring = NULL, *tmpstring2;
gchar **tmparray;
GList *rclist, *tmplist, *tmplist2;
Tconfig_list_item *tmpitem;
DEBUG_MSG("parse_config_file, started\n");
rclist = NULL;
rclist = get_list(filename, rclist,FALSE);
if (rclist == NULL) {
DEBUG_MSG("no rclist, returning!\n");
return retval;
}
/* empty all variables that have type GList ('l') */
tmplist = g_list_first(config_list);
while (tmplist != NULL) {
tmpitem = (Tconfig_list_item *) tmplist->data;
DEBUG_MSG("parse_config_file, type=%c, identifier=%s\n", tmpitem->type, tmpitem->identifier);
if (tmpitem->type == 'l' || tmpitem->type == 'a') {
DEBUG_MSG("parse_config_file, freeing list before filling it\n");
free_stringlist((GList *) * (void **) tmpitem->pointer);
*(void **) tmpitem->pointer = (GList *)NULL;
}
DEBUG_MSG("parse_config_file, type=%c, identifier=%s\n", tmpitem->type, tmpitem->identifier);
tmplist = g_list_next(tmplist);
}
DEBUG_MSG("parse_config_file, all the type 'l' and 'a' have been emptied\n");
DEBUG_MSG("parse_config_file, length rclist=%d\n", g_list_length(rclist));
/* And now for parsing every line in the config file, first check if there is a valid identifier at the start. */
tmplist = g_list_first(rclist);
while (tmplist) {
tmpstring = (gchar *) tmplist->data;
if (tmpstring != NULL) {
DEBUG_MSG("parse_config_file, tmpstring=%s\n", tmpstring);
g_strchug(tmpstring);
tmplist2 = g_list_first(config_list);
while (tmplist2) {
tmpitem = (Tconfig_list_item *) tmplist2->data;
#ifdef DEVELOPMENT
if (!tmpitem || !tmpitem->identifier || !tmpstring) {
g_print("WARNING: almost a problem!\n");
}
#endif
if (g_strncasecmp(tmpitem->identifier, tmpstring, strlen(tmpitem->identifier)) == 0) {
/* we have found the correct identifier */
retval = TRUE;
DEBUG_MSG("parse_config_file, identifier=%s, string=%s\n", tmpitem->identifier, tmpstring);
/* move pointer past the identifier */
tmpstring += strlen(tmpitem->identifier);
trunc_on_char(tmpstring, '\n');
g_strstrip(tmpstring);
switch (tmpitem->type) {
case 'i':
*(int *) (void *) tmpitem->pointer = atoi(tmpstring);
break;
case 's':
*(void **) tmpitem->pointer = (char *) realloc((char *) *(void **) tmpitem->pointer, strlen(tmpstring) + 1);
strcpy((char *) *(void **) tmpitem->pointer, tmpstring);
break;
case 'e':
tmpstring2 = unescape_string(tmpstring, FALSE); /* I wonder if that should be TRUE */
*(void **) tmpitem->pointer = (char *) realloc((char *) *(void **) tmpitem->pointer, strlen(tmpstring2) + 1);
strcpy((char *) *(void **) tmpitem->pointer, tmpstring2);
g_free(tmpstring2);
break;
case 'l':
case 'm':
tmpstring2 = g_strdup(tmpstring);
* (void **) tmpitem->pointer = g_list_prepend((GList *) * (void **) tmpitem->pointer, tmpstring2);
DEBUG_MSG("parse_config_file, *(void **)tmpitem->pointer=%p\n", *(void **) tmpitem->pointer);
break;
case 'a':
tmparray = string_to_array(tmpstring);
if (tmpitem->len <= 0 || tmpitem->len == count_array(tmparray)) {
* (void **) tmpitem->pointer = g_list_prepend((GList *) * (void **) tmpitem->pointer, tmparray);
} else {
DEBUG_MSG("parse_config_file, not storing array, count_array() != tmpitem->len\n");
g_strfreev(tmparray);
}
DEBUG_MSG("parse_config_file, *(void **)tmpitem->pointer=%p\n", *(void **) tmpitem->pointer);
break;
default:
break;
}
tmplist2 = g_list_last(tmplist2);
}
tmplist2 = g_list_next(tmplist2);
}
}
tmplist = g_list_next(tmplist);
}
DEBUG_MSG("parse_config_file, parsed all entries, freeing list read from file\n");
free_stringlist(rclist);
return retval;
}
/* parse()
*
* given a raw buffer, parses it and generates parv, parc and sender
*/
void
parse(struct Client *client_p, char *pbuffer, char *bufend)
{
struct Client *from = client_p;
char *ch;
char *s;
char *end;
int i = 1;
char *numeric = 0;
struct Message *mptr;
s_assert(MyConnect(client_p));
s_assert(client_p->localClient->fd >= 0);
if(IsAnyDead(client_p))
return;
for (ch = pbuffer; *ch == ' '; ch++) /* skip spaces */
/* null statement */ ;
para[0] = from->name;
if(*ch == ':')
{
ch++;
/* point sender to the sender param */
sender = ch;
if((s = strchr(ch, ' ')))
{
*s = '\0';
s++;
ch = s;
}
if(*sender && IsServer(client_p))
{
from = find_any_client(sender);
/* didnt find any matching client, issue a kill */
if(from == NULL)
{
ServerStats->is_unpf++;
remove_unknown(client_p, sender, pbuffer);
return;
}
para[0] = from->name;
/* fake direction, hmm. */
if(from->from != client_p)
{
ServerStats->is_wrdi++;
cancel_clients(client_p, from, pbuffer);
return;
}
}
while (*ch == ' ')
ch++;
}
if(*ch == '\0')
{
ServerStats->is_empt++;
return;
}
/* at this point there must be some sort of command parameter */
/*
* Extract the command code from the packet. Point s to the end
* of the command code and calculate the length using pointer
* arithmetic. Note: only need length for numerics and *all*
* numerics must have parameters and thus a space after the command
* code. -avalon
*/
/* EOB is 3 chars long but is not a numeric */
if(*(ch + 3) == ' ' && /* ok, lets see if its a possible numeric.. */
IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)))
{
mptr = NULL;
numeric = ch;
ServerStats->is_num++;
s = ch + 3; /* I know this is ' ' from above if */
*s++ = '\0'; /* blow away the ' ', and point s to next part */
}
else
{
int ii = 0;
if((s = strchr(ch, ' ')))
*s++ = '\0';
mptr = hash_parse(ch);
/* no command or its encap only, error */
if(!mptr || !mptr->cmd)
{
/*
* Note: Give error message *only* to recognized
* persons. It's a nightmare situation to have
* two programs sending "Unknown command"'s or
* equivalent to each other at full blast....
* If it has got to person state, it at least
* seems to be well behaving. Perhaps this message
* should never be generated, though... --msa
* Hm, when is the buffer empty -- if a command
* code has been found ?? -Armin
*/
if(pbuffer[0] != '\0')
{
if(IsPerson(from))
sendto_one(from, form_str(ERR_UNKNOWNCOMMAND),
me.name, from->name, ch);
}
ServerStats->is_unco++;
return;
}
ii = bufend - ((s) ? s : ch);
mptr->bytes += ii;
}
end = bufend - 1;
/* XXX this should be done before parse() is called */
if(*end == '\n')
*end-- = '\0';
if(*end == '\r')
*end = '\0';
if(s != NULL)
i = string_to_array(s, para);
if(mptr == NULL)
{
do_numeric(numeric, client_p, from, i, para);
return;
}
if(handle_command(mptr, client_p, from, i, /* XXX discards const!!! */ (const char **)para) < -1)
{
char *p;
for (p = pbuffer; p <= end; p += 8)
{
/* HACK HACK */
/* Its expected this nasty code can be removed
* or rewritten later if still needed.
*/
if((unsigned long) (p + 8) > (unsigned long) end)
{
for (; p <= end; p++)
{
ilog(L_MAIN, "%02x |%c", p[0], p[0]);
}
}
else
ilog(L_MAIN,
"%02x %02x %02x %02x %02x %02x %02x %02x |%c%c%c%c%c%c%c%c",
p[0], p[1], p[2], p[3], p[4], p[5],
p[6], p[7], p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
}
}
}
/* enlarge() */
static void b_enlargeRect1(task *tsk, pntr *argstack)
{
/* pointers to the parameters */
pntr val1 = argstack[1]; // originalRect
pntr val2 = argstack[0]; // times
int badtype;
/* the result value to be return */
Rectangle *rect_return = new_Rectangle();
Rectangle *originalRect = new_Rectangle();
int times;
/* Check validity of each parameter */
CHECK_ARG(1, CELL_CONS);
CHECK_ARG(0, CELL_NUMBER);
/* Initialize all arguments for this method */
/* Initialize the struct: Rectangle */
pntr originalRect_val1 = head(tsk, val1);
originalRect->width = pntrdouble(originalRect_val1);
pntr originalRect_val2 = head(tsk, tail(tsk, val1));
if( (badtype = array_to_string(originalRect_val2, &(originalRect->creator) )) > 0) {
set_error(tsk, "string: argument is not a string (contains non-char: %s)", cell_types[badtype]);
return;
}
pntr originalRect_val3 = head(tsk, tail(tsk, tail(tsk, val1)));
originalRect->height = pntrdouble(originalRect_val3);
/* Initialize another struct: Color*/
Color *originalRect_col = new_Color( );
originalRect->col = originalRect_col;
/* new root pntr for struct Color */
pntr originalRect_col_val = head(tsk, tail(tsk, tail(tsk, tail(tsk, val1))));
pntr originalRect_col_val1 = head(tsk, originalRect_col_val);
originalRect_col->red = pntrdouble(originalRect_col_val1);
pntr originalRect_col_val2 = head(tsk, tail(tsk, originalRect_col_val));
originalRect_col->blue = pntrdouble(originalRect_col_val2);
pntr originalRect_col_val3 = head(tsk, tail(tsk, tail(tsk, originalRect_col_val)));
originalRect_col->green = pntrdouble(originalRect_col_val3);
/* Initialize another struct: gray*/
gray *originalRect_col_cg = new_gray( );
originalRect_col->cg = originalRect_col_cg;
/* new root pntr for struct gray */
pntr originalRect_col_cg_val = head(tsk, tail(tsk, tail(tsk, tail(tsk, originalRect_col_val))));
pntr originalRect_col_cg_val1 = head(tsk, originalRect_col_cg_val);
if( (badtype = array_to_string(originalRect_col_cg_val1, &(originalRect_col_cg->country) )) > 0) {
set_error(tsk, "string: argument is not a string (contains non-char: %s)", cell_types[badtype]);
return;
}
pntr originalRect_col_cg_val2 = head(tsk, tail(tsk, originalRect_col_cg_val));
originalRect_col_cg->grayCode = pntrdouble(originalRect_col_cg_val2);
/* end Initialization of struct Rectangle */
times = pntrdouble(val2);
/* Call the method and get the return value */
rect_return = enlargeRect(originalRect, times);
/* Translate the resultant pntr to be return */
/* Translate C struct to ELC struct */
/* pntr for struct gray*/
pntr p_rect_return_col_cg_country = string_to_array(tsk, rect_return->col->cg->country);
pntr p_rect_return_col_cg_grayCode;
set_pntrdouble(p_rect_return_col_cg_grayCode, rect_return->col->cg->grayCode);
/* the root pntr for struct gray */
pntr p_rect_return_col_cg = make_cons(tsk, p_rect_return_col_cg_country, make_cons(tsk, p_rect_return_col_cg_grayCode, tsk->globnilpntr));
/* pntr for struct Color*/
pntr p_rect_return_col_red;
set_pntrdouble(p_rect_return_col_red, rect_return->col->red);
pntr p_rect_return_col_blue;
set_pntrdouble(p_rect_return_col_blue, rect_return->col->blue);
pntr p_rect_return_col_green;
set_pntrdouble(p_rect_return_col_green, rect_return->col->green);
/* the root pntr for struct Color */
pntr p_rect_return_col = make_cons(tsk, p_rect_return_col_red, make_cons(tsk, p_rect_return_col_blue, make_cons(tsk, p_rect_return_col_green, make_cons(tsk, p_rect_return_col_cg, tsk->globnilpntr))));
/* pntr for struct Rectangle*/
pntr p_rect_return_width;
set_pntrdouble(p_rect_return_width, rect_return->width);
pntr p_rect_return_creator = string_to_array(tsk, rect_return->creator);
pntr p_rect_return_height;
set_pntrdouble(p_rect_return_height, rect_return->height);
/* the root pntr for struct Rectangle */
pntr p_rect_return = make_cons(tsk, p_rect_return_width, make_cons(tsk, p_rect_return_creator, make_cons(tsk, p_rect_return_height, make_cons(tsk, p_rect_return_col, tsk->globnilpntr))));
/* set the return value */
argstack[0] = p_rect_return;
/* Free the return struct */
free_Rectangle(rect_return);
}
//// read the directory entries of given dir/archive
static void b_zzip_read_dirent(task *tsk, pntr *argstack)
{
char *fileName;
pntr p = argstack[0];
int badtype;
CHECK_ARG(0, CELL_CONS);
if((badtype = array_to_string(p, &fileName)) >= 0){
set_error(tsk, "error1: argument is not a string (contains non-char: %s)", cell_types[badtype]);
return;
}
ZZIP_DIR * dir;
ZZIP_DIRENT * d;
dir = zzip_opendir(fileName);
if (! dir){
fprintf (stderr, "did not open %s: ", fileName);
set_error(tsk, "error1: could not handle file: %s", fileName);
return;
}
char *singleFileName;
char *compressionType;
int fSize = 20;
char fileSize[fSize];
char compressedSize[fSize];
pntr pSingleFileName, pCompressionType, pFileSize, pCompressedSize;
pntr preList, singleList;
int counter = 0;
/* read each dir entry, a list for each file */
while ((d = zzip_readdir (dir))){
counter++;
/* orignal size / compression-type / compression-ratio / filename */
singleFileName = d->d_name;
pSingleFileName = string_to_array(tsk, singleFileName); //// convert the string to cons list
// sprintf(compressionType, "%s ", zzip_compr_str(d->d_compr)); //// NOTE: executing this func will change the tsk->steamstack, very weird
//// NOTE: overflow caused here
compressionType = (char *)zzip_compr_str(d->d_compr);
pCompressionType = string_to_array(tsk, compressionType);
// snprintf(fileSize, 5, "%d ", d->st_size); //// NOTE: executing this func will change the tsk->steamstack, very weird
format_double(fileSize, fSize, d->st_size);
pFileSize = string_to_array(tsk, fileSize);
// sprintf(compressedSize, "%d ", d->d_csize);
format_double(compressedSize, fSize, d->d_csize);
pCompressedSize = string_to_array(tsk, compressedSize);
// printf("cell type: %s \t", cell_type(preList));
//// link the cons lists to form a new list
// singleList = connect_lists(tsk, &pSingleFileName, &pCompressionType);
// singleList = connect_lists(tsk, &singleList, &pFileSize);
// singleList = connect_lists(tsk, &singleList, &pCompressedSize);
//// make cons from the last element to the beginning element
singleList = make_cons(tsk, pCompressedSize, tsk->globnilpntr);
singleList = make_cons(tsk, pFileSize, singleList);
singleList = make_cons(tsk, pCompressionType, singleList);
singleList = make_cons(tsk, pSingleFileName, singleList);
if(counter == 1){
preList = make_cons(tsk, singleList, tsk->globnilpntr);
// printf("cell type: %s \t", cell_type(preList));
}else{
preList = make_cons(tsk, singleList, preList);
// printf("cell type: %s \n", cell_type(preList));
}
}
argstack[0] = preList;
// printf("cell type: %s \n", cell_type(argstack[0]));
}
int main(int argc, char **argv) {
char * tmpdir = getenv("_FAKEUSER_DIR_");
char *passwd_file, *group_file;
name = argv[0];
int opt, ret = 0;
int action = 0, uid = 0, gid = 0;
char *name = NULL, *passwd = NULL, *members = NULL, *shell = NULL, *gecos = NULL, *dir = NULL;
extern char *optarg;
while ((opt = getopt(argc, argv, "UGu:g:n:p:m:s:c:d:h")) != -1) {
switch (opt) {
case 'U':
action = 'U';
break;
case 'G':
action = 'G';
break;
case 'u':
uid = atoi(optarg);
break;
case 'g':
gid = atoi(optarg);
break;
case 'n':
name = optarg;
break;
case 'p':
passwd = optarg;
break;
case 'm':
members = optarg;
break;
case 's':
shell = optarg;
break;
case 'c':
gecos = optarg;
break;
case 'd':
dir = optarg;
break;
case 'h':
help();
exit(EXIT_SUCCESS);
default: /* '?' */
usage_fd(stderr);
exit(EXIT_FAILURE);
}
}
if (action == 0 || name == NULL) {
usage();
exit(EXIT_FAILURE);
}
// only continue when environment variable with directory found.
if (!tmpdir) {
fputs("Error! Not in fakeuser environment\n", stderr);
exit(EXIT_FAILURE);
}
// init file paths
passwd_file = (char*)malloc(strlen(tmpdir)+10);
strcpy(passwd_file, tmpdir);
strcat(passwd_file, "/passwd");
group_file = (char*)malloc(strlen(tmpdir)+10);
strcpy(group_file, tmpdir);
strcat(group_file, "/group");
// Create directory structure
mkdir_r(tmpdir, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
if (action == 'U') {
// create and append passwd entry
struct passwd pw;
pw.pw_name = name;
pw.pw_passwd = passwd ? passwd : "";
pw.pw_gecos = gecos ? gecos : "";
pw.pw_dir = dir ? dir : "";
pw.pw_shell = shell ? shell : "";
pw.pw_uid = uid;
pw.pw_gid = gid;
// append to file with error handling.
FILE * pwf = fopen(passwd_file, "a");
if (pwf) {
if(putpwent(&pw, pwf))
ret = EIO;
if (fclose(pwf))
ret = EIO;
} else
ret = EIO;
} else if (action == 'G') {
// create and append group entry
struct group gr;
gr.gr_name = name;
gr.gr_passwd = passwd ? passwd : "";
gr.gr_gid = gid;
char *strings;
gr.gr_mem = members ? string_to_array(members, " ,;", &strings) : (char *[]) {
NULL
};
// append to file with error handling.
FILE * pwf = fopen(group_file, "a");
if (pwf) {
if(putgrent(&gr, pwf))
ret = EIO;
if (fclose(pwf))
ret = EIO;
} else
ret = EIO;
}
// return 0 on success or the error value
return ret;
}
