char *get_value(char *name, char **env)
{
int k;
int i;
int j;
char *ret;
k = 0;
while (env[k] != NULL)
{
if (strncmp(name, env[k], utl_strlen(name)) == 0)
{
if ((ret = malloc_str(sizeof(*ret) *
(utl_strlen(env[k]) + 1))) == NULL)
return (name);
i = 0;
j = 0;
while (i <= utl_strlen(name) && env[k][i] != 0)
i++;
while (env[k][i] != 0)
ret[j++] = env[k][i++];
ret[j] = 0;
return (ret);
}
k++;
}
return (name);
}
void get_env_var(t_cmd *cmd, t_system *sys)
{
char *tp;
int k;
int i;
int j;
k = 0;
while (cmd->args[k] != NULL)
{
if (cmd->args[k][0] == '$' && cmd->args[k][1] != 0)
{
if ((tp = malloc_str(sizeof(*tp) *
(utl_strlen(cmd->args[k]) + 1))) == NULL)
return;
i = 0;
j = 1;
while (cmd->args[k][j] != 0)
tp[i++] = cmd->args[k][j++];
tp[i] = 0;
args_modifier(cmd, tp, sys, k);
free(tp);
}
k++;
}
}
struct node *putloop(struct node
void testcases()
{
struct node *res1,*ptr1,*ptr2,*res;
char *ip1,*op;
int i,check;
for(i=0;i<2;i++)
{
res1=NULL;
ip1=NULL;
ip1=NULL;
ip1=malloc_str(testDB[i].input1);
ip1=valid_str(ip1);
if(ip1!=NULL)
{
ip1=rem_space(ip1);
res1=create_list(ip1);
res1=putloop(res1);
res1=removeloop(res1);
}
display(res);
free(op);
free(ip1);
free(res);
free(output);
}
}
char * splitkey(char * key, int maxkey, char * val, int maxvalue, const char ** pend, const char * buf)
{
const char * pv;
char *backupstr;
if(!buf && *buf)
return 0;
backupstr = malloc_str(buf, -1);
*key = 0;
*val = 0;
pv = strchr_s(backupstr, '=');
if(pv != NULL)
{
backupstr[pv-backupstr] = ' '; //将key和alue使用空格分割
getkey(key, maxkey, 0, backupstr);
getkey(val, maxvalue, pend, pv);
}
else
{
getkey(key, maxkey, pend, backupstr);
}
free(backupstr);
if(*key == 0)
return 0;
return key;
}
int get_next_line(const int fd, char **line)
{
char buff[BUFF_SIZE + 1];
int ret;
static t_stock *list = NULL;
char **str;
str = multi_fd(fd, &list);
if (fd < 0 || !line || read(fd, buff, 0) < 0)
return (-1);
if (*str == NULL)
{
*str = ft_strdup("\0");
}
while ((ret = read(fd, buff, BUFF_SIZE)) > 0)
{
*str = (ft_concat(buff, ret, *str));
if (ft_strstr(*str, "\n") != NULL)
break ;
}
*str = malloc_str(*str, line);
if (*str == NULL && ft_strcmp(*line, "\0") == 0)
return (0);
return (1);
}
void testcases()
{
struct node *res,*output;
char *ip,*op;
int i,check;
for(i=0;i<9;i++)
{
res=output=NULL;
ip=op=NULL;
ip=malloc_str(testDB[i].input);
ip=valid_str(ip);
//if(ip==NULL)
//printf("hai\n");
if(ip!=NULL)
{
ip=rem_space(ip);
res=create_list(ip);
//display(res);
res=swap_adj_nodes(res);
}
else
{
res=NULL;
}
op=malloc_str(testDB[i].output);
output=create_list(op);
//if(res==NULL)
check=list_cmp(res,output);
display(res);
display(output);
if(check==0)
printf("passed\n");
else
printf("failed\n");
free(op);
free(ip);
free(res);
free(output);
}
}
void anlizetextbtw(const char * buf, callback deal, void * parm)
{
char * texttw;
const char * pstart = strchr_s(buf, '<');
if(pstart == 0 || pstart-buf == 0)
return ;
texttw = malloc_str(buf, pstart-buf);
deal(MARK_BTW, texttw, pstart-buf, parm);
free(texttw);
}
static void compile(route *route, char *path) {
int status, pos = 0;
regex_t *result = malloc(sizeof(regex_t));
regmatch_t matches[2];
char *named_param_re_src = "([^/]*)";
char *matcher_re_src = malloc_str(strlen(path) * 2);
// capture named params and build regex
while ((status = regexec(configuration_get()->param_match_regex, path + pos, 2, matches, 0)) == 0) {
int match_length = matches[1].rm_eo - matches[1].rm_so;
// get everething before parameter in url - step 1: /foo/(:bar)/test -> /foo/
memcpy(matcher_re_src + strlen(matcher_re_src), path + pos, matches[0].rm_so);
// put parameter regex - step 2: /foo/(:bar)/test -> /foo/([^/]*)
memcpy(matcher_re_src + strlen(matcher_re_src), named_param_re_src, strlen(named_param_re_src));
// capture named parameter name to use later during match
char *parameter = malloc_str(match_length);
memcpy(parameter, path + pos + matches[1].rm_so, matches[1].rm_eo - matches[1].rm_so);
route->named_params[route->named_params_count] = parameter;
route->named_params_count++;
// advance
pos += matches[0].rm_eo;
}
// remaining url part - step 3: /foo/(:bar)/test -> /foo/([^/]*)/test
memcpy(matcher_re_src + strlen(matcher_re_src), path + pos, strlen(path) - pos);
char *regex = malloc_str(strlen("^") + strlen(matcher_re_src) + strlen("$"));
sprintf(regex, "^%s$", matcher_re_src);
if(regcomp(result, regex, REG_EXTENDED) != 0) {
die("Cannot compile dynamic matcher for route: %s", path);
}
free(regex);
free(matcher_re_src);
route->matcher = result;
}
bool route_match(route *route, const char *path, params_map *params) {
regmatch_t matches[route->named_params_count + 1];
int status = regexec(route->matcher, path, route->named_params_count + 1, matches, 0);
bool match = (status == 0);
if (match && route->named_params_count > 0) {
int i = 0;
for (i = 0; i < route->named_params_count; i++) {
int length = matches[i + 1].rm_eo - matches[i + 1].rm_so;
char *param_value = malloc_str(length);
memcpy(param_value, path + matches[i + 1].rm_so, length);
params_map_add_str(params, route->named_params[i], param_value);
free(param_value);
}
}
return match;
}
void testcases()
{
struct node *res;
char *ip;
int i,check;
float res1;
for(i=0;i<10;i++)
{
res=NULL;
ip=NULL;
ip=malloc_str(testDB[i].input);
ip=valid_str(ip);
if(ip!=NULL)
{
ip=rem_space(ip);
res=create_list(ip);
res=mergesort(res);
res1=get_median(res);
}
else
{
res1=0;
}
check=val_cmp(res1,testDB[i].value);
//printf("%f\t%f\n",res1,testDB[i].value);
if(check==0)
printf("passed\n");
else
printf("failed\n");
free(ip);
free(res);
}
}
char *params_map_serialize(params_map *p_map) {
dictIterator *dict_iterator;
dictEntry *dict_entry;
param_entry *param;
char *line, *result = NULL;
dict_iterator = dictGetIterator(p_map);
while((dict_entry = dictNext(dict_iterator)) != NULL) {
param = (param_entry *)dictGetEntryVal(dict_entry);
line = malloc_str(strlen("[") + strlen(param->name) + strlen(":") + strlen(param->val) + strlen("]"));
sprintf(line, "[%s:%s]", param->name, param->val);
result = str_concat(result, line);
free(line);
}
free(dict_iterator);
if (result == NULL) result = strdup("Params hash is empty");
return result;
}
static char *copy_chunk_from_buffer(const char *buf, size_t len) {
char *field = malloc_str(len);
strncat(field, buf, len);
return field;
}
char *build_header_header(http_response *response) {
char *result = malloc_str(3 + strlen("HTTP/1.1 XXX ") + strlen(response->header_summary) + strlen("\n"));
sprintf(result, "HTTP/1.1 %d %s\n", response->code, response->header_summary);
return result;
}
const char * anlizetext(const char * mark, const char * buf, callback deal, void * parm)
{
char * marklow = (char *)malloc(strlen(mark)+1);
strtolower(marklow, mark);
if(marklow[0] != '/')
{
int count = 1;
char bname[1024];
char nameend[1024];
char tmpmark[1024];
const char * bufbp = buf;
const char * next = buf;
strcpy(nameend, "/");
strcat(nameend, marklow);
if(!strcmp(marklow, "script")) // 跳过关于script内部的内容
{
char * tw = 0;
strcpy(nameend, "</");
strcat(nameend, marklow);
buf = getmark(nameend, buf);
if(buf == 0)
{
free(marklow);
return bufbp;
}
tw = malloc_str(bufbp, buf-bufbp);
if(tw)
{
deal(MARK_BTW, tw, buf-bufbp, parm);
free(tw);
}
count = 0;
}
while(count)
{
buf = next;
if(!anlizemark(tmpmark, 1024, &next, buf))
break ;
if(isnote(tmpmark))
continue;
if(!getkey(bname, 1024, 0, tmpmark))
break;
strtolower(bname, bname);
if(!strcmp(bname, marklow))
count++;
if(!strcmp(bname, nameend))
count--;
buf = strchr_s(buf, '<');
}
while(count == 0)
{
char * tmpbuf = malloc_str(bufbp, buf-bufbp);
if(!tmpbuf)
break;
deal(MARK_TXT, tmpbuf, buf-bufbp+1, parm);
free(tmpbuf);
break;
}
}
free(marklow);
return buf;
}
