node* get_list_from_token_str(char *str, char* delimiter) {
char *name, *eq, *value;
node *this, *prev;
if (!str) return NULL;
this = prev = NULL;
name = strtok(str, delimiter);
while (name) {
eq = memchr(name, '=', strlen(name));
if (!eq) break;
value = eq + 1;
*eq = 0;
name = trim_space(name);
value = trim_space(value);
this = (node*) malloc(sizeof(node));
//printf("name:%s.\n", name);
//printf("val:%s.\n", value);
strcpy(this->name, name);
strcpy(this->value, value);
this->next = prev;
prev = this;
name = strtok(NULL, delimiter);
}
return reverse_list(this);
}
/**
* tests helper functions is_var() and is_op()
*/
static char * test_helpers() {
char tmp[VAR_LENGTH+1], str[LINE_LENGTH];
char * trimmed;
int ret, i;
printf("Testing %s\n", __FUNCTION__);
/* test is_var() from A-Z */
for (i='A'; i<='Z'; i++) {
tmp[0] = i;
tmp[1] = '\0';
ret = is_var(tmp);
mu_assert("error, ret != 1", ret == 1);
}
/* test bogus inputs */
/* small letter */
tmp[0] = 'a';
ret = is_var(tmp);
mu_assert("error, ret != 0", ret == 0);
/* number */
tmp[0] = '1';
ret = is_var(tmp);
mu_assert("error, ret != 0", ret == 0);
/* test is_op */
tmp[0] = '+';
ret = is_op(tmp);
mu_assert("error, ret != 1", ret == 1);
tmp[0] = '-';
ret = is_op(tmp);
mu_assert("error, ret != 1", ret == 1);
tmp[0] = '*';
ret = is_op(tmp);
mu_assert("error, ret != 1", ret == 1);
tmp[0] = '/';
ret = is_op(tmp);
mu_assert("error, ret != 1", ret == 1);
/* test bogus inputs */
tmp[0] = '=';
ret = is_op(tmp);
mu_assert("error, ret != 0", ret == 0);
tmp[0] = '^';
ret = is_op(tmp);
mu_assert("error, ret != 0", ret == 0);
tmp[0] = '$';
ret = is_op(tmp);
mu_assert("error, ret != 0", ret == 0);
/* test trim_space() */
strcpy(str, "\t\tFD 30 \t\t ");
trimmed = trim_space(str);
mu_assert("error, trimmed != \"FD 30\"", strsame(trimmed, "FD 30"));
strcpy(str, " \t \tDO A FROM 1 TO 8 { \t\t ");
trimmed = trim_space(str);
mu_assert("error, trimmed != \"DO A FROM 1 TO 8 {\"", strsame(trimmed, "DO A FROM 1 TO 8 {"));
return 0;
}
void lxadv(struct lexer *lx, struct tok *tk)
{
trim_space(lx);
if (lx->cur == '\'') {
strcpy(tk->lexeme, "'");
tk->kind = TK_QUOTE;
lxadvch(lx);
} else if (isid(lx->cur)) {
if (isdigit(lx->cur))
get_num(lx, tk);
else
get_id(lx, tk);
} else if (lx->cur == '(') {
strcpy(tk->lexeme, "(");
tk->kind = TK_LPAR;
lxadvch(lx);
} else if (lx->cur == ')') {
strcpy(tk->lexeme, ")");
tk->kind = TK_RPAR;
lxadvch(lx);
} else if (lx->cur == '\0' || lx->cur == EOF) {
tk->kind = TK_EOF;
}
}
static void read_conf(struct gale_text fn) {
struct gale_text line;
FILE * const fp = fopen(gale_text_to(gale_global->enc_filesys,fn),"r");
if (NULL == fp) return;
line = gale_read_line(fp);
while (line.l > 0) {
struct gale_text var;
struct gale_text_accumulator val = null_accumulator;
int i;
line = trim_space(line);
if (0 == line.l || '#' == line.p[0]) {
line = gale_read_line(fp);
continue;
}
i = 1;
while (i < line.l && !is_space(line.p[i])) ++i;
var = gale_text_left(line,i);
while (i < line.l && is_space(line.p[i])) ++i;
gale_text_accumulate(&val,gale_text_right(line,-i));
line = gale_read_line(fp);
while (line.l > 0
&& (line.p[0] == ' ' || line.p[0] == '\t' || line.p[0] == '#')) {
line = trim_space(line);
if (0 == line.l) {
line = gale_read_line(fp);
break;
}
if ('#' != line.p[0]) gale_text_accumulate(&val,line);
line = gale_read_line(fp);
}
if (0 == gale_var(var).l) {
struct gale_text value = gale_text_collect(&val);
while (value.l > 0 && is_space(value.p[value.l - 1]))
--value.l;
gale_set(var,trim_space(value));
}
}
fclose(fp);
}
bool OEFind::read_oedata()
{
e_document_ex doc;
char filename[1024];
char confname[1024];
bool exist_flag=false;
sprintf(filename,"%s/OEData.e",conf_dir);
QString filename_CN = filename_CN.fromLocal8Bit(filename);//中文路径无法识别
QFile OEData_file(filename_CN);
if(!OEData_file.open(QIODevice::ReadOnly))
{
exist_flag = true;
sprintf(confname,"%s/conf2",conf_dir);
QString confname_CN = confname_CN.fromLocal8Bit(confname);
QFile conf(confname_CN);
if(!conf.open(QIODevice::ReadOnly))
return false;
QByteArray OEData_Array=QByteArray::fromBase64(conf.readAll());
if(!OEData_file.open(QIODevice::WriteOnly))
return false;
OEData_file.write(OEData_Array);
OEData_file.close();
conf.close();
}
OEData_file.close();
if(!doc.parse_file(filename))
return false;
E2DDE efile_BaseData(db_read.scheme());
efile_BaseData.parse(db_read, doc, e_dde_parse_combine);
if(exist_flag)
{
QString filename_CN = filename_CN.fromLocal8Bit(filename);
QFile::remove(filename_CN);
}
DDETable *OEData_tb = db_read.get("OEData");
if (!OEData_tb)
return false;
size_t size = OEData_tb->size();
if(!size)
return false;
for(size_t i=0;i<size;i++) //建立映射关系
{
OEData *data = reinterpret_cast<OEData*>(OEData_tb->at(i));
char *code = OEData_tb->allocate_string(data->oe_code);
trim_space(code);
brand_oedata_map[data->brand][code] = data;
}
return true;
}
void RFC822HeadersRead(FILE *in,const List *list)
{
char *line;
char *t;
struct pair *ppair;
assert(in != NULL);
assert(list != NULL);
while((line = RFC822LineRead(in)) != NULL)
{
t = line;
ppair = PairNew(&t,':','\0');
ppair->name = trim_space(ppair->name);
ppair->value = trim_space(ppair->value);
up_string(ppair->name);
ListAddTail((List *)list,&ppair->node);
free(line);
}
}
static void trim_space(struct lexer *lx)
{
while (isspace(lx->cur))
lxadvch(lx);
if (lx->cur == ';') {
lxadvch(lx);
while (lx->cur != '\n' && lx->cur != EOF)
lxadvch(lx);
trim_space(lx);
}
}
END_TEST
START_TEST(test_trim_space)
{
char line1[] = " Host: localhost ";
char expc1[] = "Host: localhost";
char line2[] = " Host: localhost";
char expc2[] = "Host: localhost";
char line3[] = " ";
char expc3[] = "";
trim_space(line1);
fail_unless(strcmp(expc1, line1) == 0, "Failed to parse the line %s]\n", line1);
trim_space(line2);
fail_unless(strcmp(expc2, line2) == 0, "Failed to parse the line %s]\n", line2);
trim_space(line3);
fail_unless(strcmp(expc3, line3) == 0, "Failed to parse the line %s]\n", line3);
}
void get_memory_range_and_permission(char *line, Section *s) {
const char deli[2] = " ";
char *mem_range = strtok(line, deli);
char *perm = strtok(NULL, deli);
char *offset = strtok(NULL, deli);
char *dev = strtok(NULL, deli);
char *inode = strtok(NULL, deli);
char *name = strtok(NULL, deli);
// check permission, if there is no read permission or it's shared memory, pass
if (perm[0] == '-' || perm[strlen(perm) - 1] == 's') return;
// check if it's for 'vsyscall', if true pass
if (strcmp(trim_space(name), "[vsyscall]") == 0) return;
strcpy(s->perm, perm);
process_mem_range(mem_range, s);
}
/*
功能：
解析类似
"key1 = value1"
" key2 = value2 "
↑
"key3 = hello word "
"key4 = value4"
"key5 = "
"key6 ="
以下风格字符串，通过key，得到value
key_value_buf IN ： 要解析的源字符串
key_buf IN : 要查找的key值
value_buf OUT: 得到的最终value值
value_buf_len OUT: 得到的value的长度
return 0 成功 -1 失败
*/
int get_key_by_value(char *key_value_buf, char *key_buf, char *value_buf, int *value_buf_len)
{
char *p = key_value_buf; //源字符串
char *key = key_buf; //需要查找的key
//char *dst_buf = value_buf;
int value_len = 0;
if (key_value_buf == NULL || key_buf == NULL || value_buf == NULL || value_buf_len == NULL)
{
printf("key_value_buf == NULL || key_buf == NULL || value_buf == NULL || value_buf_len == NULL\n");
return -1;
}
//写具体的过程
//查找源字符串中是否有key
p = strstr(p, key);
if (p == NULL)
{
//没找到key
printf("未找到 %s\n", key);
return -1;
}
//判断源字符串中 是否有 =
p = strstr(p, "=");
if (p == NULL)
{
//没找到=
printf("未找到 = \n");
return -1;
}
p += strlen("=");
//将= 右边的有空白字符的字符串，进行两边的空白去掉
if (trim_space(p, value_buf) < 0)
{
printf("trim_space error\n");
return -1;
}
value_len = strlen(value_buf);
*value_buf_len = value_len;
return 0;
}
int main()
{
char buf[128];
char l[128];
while(memset(buf, 0, 128), memset(l, 0,128), fgets(buf, 128, stdin) != NULL)
{
if(buf[0] != '\n')
{
trim_space(buf);
reverse(buf);
reverse_word(buf, l);
printf("reverse:\n%s\n", l);
}
}
return 0;
}
/* Read all parameters from the files */
void read_param(char *file_name)
{
FILE *fp;
char buf[MAXLEN],*c,*word;
TextLine *line;
double number;
int i,n,rinput[NINPUT];
for(i=0;i<NINPUT;i++)
rinput[i] = FALSE;
error = 0;
line = NULL;
fp = fopen(file_name,"r");
if(fp == NULL){
error_dialog_open(file_name);
return;
}
while(fgets(buf,MAXLEN,fp)!=NULL){
i = 0;
while(i<NINPUT && (c=strstr(buf,inlines[i]))==NULL)
i++;
if(i<NINPUT){
c += strlen(inlines[i]);
c = trim_space(c);
}
switch(i){
case I_TYPE:
if(c != NULL && strcmp(c, "")){
word = get_word(c,&n); /* we should free word-memory also! */
if(strcmp(word,"ERD") == 0)
sim_type = SIM_ERD;
else if(strcmp(word,"RBS") == 0)
sim_type = SIM_RBS;
else{
sim_type = SIM_ERD;
error = 1;
}
free(word);
}
else{
sim_type = SIM_ERD;
error = 1;
}
break;
case I_ION:
if(c != NULL){
if(strcmp(c, "")){
c = get_string(c);
beam_ion = c;
}
else
beam_ion = "";
}
else{
beam_ion = "";
error = 1;
}
break;
case I_ENERGY:
if(c != NULL && strcmp(c, "")){
c = get_number(c,&number);
beam_energy = number;
}
else{
beam_energy = 0;
error = 1;
}
break;
case I_RECOIL:
if(c != NULL){
if(strcmp(c, "")){
c = get_string(c);
recoil_atom = c;
}
else
recoil_atom = "";
}
else{
recoil_atom = "";
error = 1;
}
break;
case I_TANGLE:
if(c != NULL && strcmp(c, "")){
c = get_number(c,&number);
target_angle = number;
}
else{
target_angle = 0;
error = 1;
}
break;
case I_SPOTSIZE:
if(c != NULL && strcmp(c, "")){
c = get_number(c,&number);
beam_size_x = number;
}
else{
beam_size_x = 0;
error = 1;
}
if(c != NULL && strcmp(c, "")){
c = get_number(c,&number);
beam_size_y = number;
}
else{
beam_size_y = 0;
error = 1;
}
break;
case I_MINANGLE:
if(c != NULL && strcmp(c, "")){
c = get_number(c,&number);
min_angle = number;
}
else{
min_angle = 0;
error = 1;
}
break;
case I_MINENERGY:
if(c != NULL && strcmp(c, "")){
c = get_number(c,&number);
min_energy = number;
}
else{
min_energy = 0;
error = 1;
}
break;
case I_NIONS:
if(c != NULL && strcmp(c, "")){
c = get_number(c,&number);
nions = number;
}
else{
nions = 0;
error = 1;
}
break;
case I_NPREIONS:
if(c != NULL && strcmp(c, "")){
c = get_number(c,&number);
nions_presim = number;
}
else{
nions_presim = 0;
error = 1;
}
break;
case I_RECAVE:
if(c != NULL && strcmp(c, "")){
c = get_number(c,&number);
aver_nions = number;
}
else{
aver_nions = 0;
error = 1;
}
break;
case I_SEED:
if(c != NULL && strcmp(c, "")){
c = get_number(c,&number);
nseed = number;
}
else{
nseed = 0;
error = 1;
}
break;
case I_RECWIDTH:
if(c != NULL && strcmp(c, "")){
word = get_word(c,&n);
if(strcmp(word,"wide") == 0 || strcmp(word,"WIDE") == 0)
angle_width = REC_WIDE;
else if(strcmp(word,"narrow") == 0 || strcmp(word,"NARROW") == 0)
angle_width = REC_NARROW;
else{
angle_width = REC_NARROW;
error = 1;
}
free(word);
}
else{
angle_width = REC_NARROW;
error = 1;
}
break;
default:
break;
}
}
read_target_file(file_name, TYPE_TARGET);
read_target_file(file_name, TYPE_FOIL);
read_detector_file(file_name);
read_rdist_file(file_name);
read_presimu_file(file_name);
read_espe_params_file(file_name);
/* If error occurs somewhere */
if(error)
error_dialog("Problems with reading the data");
fclose(fp);
/* Clean "memory" */
format_layers(nlayers);
format_foils(nfoils);
saved = 1;
}
static int verify_data(spctx_t* ctx)
{
char ebuf[256];
int n;
SPF_request_t *spf_request = NULL;
char * xforwardaddr = NULL;
char * xforwardhelo = NULL;
if(spf_server == NULL)
{
/* redirect errors */
SPF_error_handler = SPF_error_syslog;
SPF_warning_handler = SPF_warning_syslog;
SPF_info_handler = SPF_info_syslog;
SPF_debug_handler = SPF_debug_syslog;
spf_server = SPF_server_new(SPF_DNS_CACHE, 1);
if (spf_server == NULL)
return -1;
}
/* trim string */
if(ctx->xforwardaddr)
xforwardaddr = trim_space(ctx->xforwardaddr);
if(ctx->xforwardhelo)
xforwardhelo = trim_space(ctx->xforwardhelo);
sp_messagex(ctx, LOG_DEBUG, "New connection: ADDR %s - MAIL FROM %s - XF-ADDR %s - XF-HELO %s",
ctx->client.peername, ctx->sender, xforwardaddr, xforwardhelo);
spf_request = SPF_request_new(spf_server);
if( xforwardaddr )
SPF_request_set_ipv4_str( spf_request, xforwardaddr );
else if ( ctx->client.peername )
SPF_request_set_ipv4_str( spf_request, ctx->client.peername );
if( xforwardhelo )
SPF_request_set_helo_dom( spf_request, xforwardhelo );
if( ctx->sender )
SPF_request_set_env_from( spf_request, ctx->sender );
SPF_response_t *spf_response = NULL;
SPF_request_query_mailfrom(spf_request, &spf_response);
char hostname[100];
strncpy(hostname, SPF_request_get_rec_dom(spf_request), 99);
char *result_spf = NULL;
switch(SPF_response_result(spf_response))
{
case SPF_RESULT_NONE:
sp_messagex(ctx, LOG_DEBUG, "No SPF policy found for %s", ctx->sender);
result_spf = "none";
break;
case SPF_RESULT_NEUTRAL:
result_spf = "neutral";
sp_messagex(ctx, LOG_DEBUG, "SPF: NEUTRAL for %s", ctx->sender);
break;
case SPF_RESULT_SOFTFAIL:
result_spf = "softfail";
sp_messagex(ctx, LOG_DEBUG, "SPF: SOFTFAIL for %s", ctx->sender);
break;
case SPF_RESULT_PASS:
result_spf = "pass";
sp_messagex(ctx, LOG_DEBUG, "SPF: PASS for %s", ctx->sender);
break;
case SPF_RESULT_FAIL:
buffer_reject_message("550 SPF Reject", ebuf, sizeof(ebuf));
buffer_reject_message(SPF_response_get_smtp_comment(spf_response), ebuf, sizeof(ebuf));
final_reject_message(ebuf, sizeof(ebuf));
sp_messagex(ctx, LOG_DEBUG, "SPF FAIL for %s, ignore message", ctx->sender);
SPF_response_free(spf_response);
SPF_request_free(spf_request);
if(sp_fail_data(ctx, ebuf) == -1)
return -1;
else
return 0;
break;
case SPF_RESULT_TEMPERROR:
case SPF_RESULT_PERMERROR:
case SPF_RESULT_INVALID:
buffer_reject_message("450 temporary failure", ebuf, sizeof(ebuf));
final_reject_message(ebuf, sizeof(ebuf));
sp_messagex(ctx, LOG_DEBUG, "TEMP ERROR or INVALID RECORD in SPF for %s", ctx->sender);
SPF_response_free(spf_response);
SPF_request_free(spf_request);
if(sp_fail_data(ctx, ebuf) == -1)
return -1;
else
return 0;
break;
};
char auth_result_spf[1025];
snprintf(auth_result_spf, 1024, "spf=%s smtp.mailfrom=%s", result_spf, ctx->sender);
SPF_response_free(spf_response);
SPF_request_free(spf_request);
/* Tell client to start sending data */
if(sp_start_data (ctx) < 0)
return -1; /* Message already printed */
/* Setup DKIM verifier */
DKIMContext ctxt;
DKIMVerifyOptions vopts = {0};
vopts.nCheckPractices = 1;
vopts.pfnSelectorCallback = NULL; //SelectorCallback;
n = DKIMVerifyInit( &ctxt, &vopts );
/* Read data into verifier */
int len = -1;
const char *buffer = 0;
do
{
len = sp_read_data(ctx, &buffer);
if(len == -1)
return -1;
if(len > 0)
{
DKIMVerifyProcess( &ctxt, buffer, len );
sp_write_data( ctx, buffer, len );
}
} while(len > 0);
sp_write_data( ctx, NULL, 0 );
/* Verify DKIM */
n = DKIMVerifyResults( &ctxt );
/* Get verification details */
int nSigCount = 0;
DKIMVerifyDetails* pDetails;
char szPolicy[512];
DKIMVerifyGetDetails(&ctxt, &nSigCount, &pDetails, szPolicy );
/* Proxy based on verification results */
char auth_result_dkim[1025];
if(nSigCount == 0)
{
sp_messagex(ctx, LOG_DEBUG, "No DKIM signature, passthrough");
snprintf(auth_result_dkim, 1024, "dkim=none");
}
else if (n == DKIM_SUCCESS || n == DKIM_PARTIAL_SUCCESS)
{
sp_messagex(ctx, LOG_DEBUG, "DKIM verification: Success, adding header information");
int strpos = 0;
int i=0;
for(; i<nSigCount; ++i)
{
snprintf(&auth_result_dkim[strpos], 1024 - strpos,
"%sdkim=%s header.d=%s", (i>0 ? ";\n" : ""),
(pDetails[i].nResult == DKIM_SUCCESS ? "pass" : "fail"),
pDetails[i].szSignatureDomain);
strpos = strlen(auth_result_dkim);
}
} else {
sp_messagex(ctx, LOG_DEBUG, "DKIM verification: Failed, report error and ignore message.");
buffer_reject_message("550 DKIM Signature failed verification (http://www.dkim.org/info/dkim-faq.html)", ebuf, sizeof(ebuf));
final_reject_message(ebuf, sizeof(ebuf));
DKIMVerifyFree( &ctxt );
if(sp_fail_data(ctx, ebuf) == -1)
return -1;
else
return 0;
}
DKIMVerifyFree( &ctxt );
char auth_results_header[1025];
snprintf(auth_results_header, 1024, "Authentication-Results: %s;\n %s;\n %s;",
hostname, auth_result_spf, auth_result_dkim);
if( sp_done_data(ctx, auth_results_header) == -1)
return -1;
return 0;
}
/*===========================================================================
FUNCTION loc_read_gps_conf
DESCRIPTION
Reads the gps.conf file and sets global parameter data
DEPENDENCIES
N/A
RETURN VALUE
None
SIDE EFFECTS
N/A
===========================================================================*/
void loc_read_gps_conf(void)
{
FILE *gps_conf_fp = NULL;
char input_buf[LOC_MAX_PARAM_LINE]; /* declare a char array */
char *lasts;
char *param_name, *param_str_value;
int param_value;
int i;
loc_default_parameters();
if((gps_conf_fp = fopen(GPS_CONF_FILE, "r")) != NULL)
{
LOC_LOGD("loc_read_gps_conf: using %s", GPS_CONF_FILE);
}
else
{
LOC_LOGW("loc_read_gps_conf: no %s file, using defaults", GPS_CONF_FILE);
return; /* no parameter file */
}
while(fgets(input_buf, LOC_MAX_PARAM_LINE, gps_conf_fp) != NULL)
{
/* Separate variable and value */
param_name = strtok_r(input_buf, "=", &lasts);
if (param_name == NULL) continue; /* skip lines that do not contain "=" */
param_str_value = strtok_r(NULL, "=", &lasts);
if (param_str_value == NULL) continue; /* skip lines that do not contain two operands */
/* Trim leading and trailing spaces */
trim_space(param_name);
trim_space(param_str_value);
// printf("*(%s) = (%s)\n", param_name, param_str_value);
/* Parse numerical value */
if (param_str_value[0] == '0' && tolower(param_str_value[1]) == 'x')
{
/* hex */
param_value = (int) strtol(¶m_str_value[2], (char**) NULL, 16);
}
else {
/* dec */
param_value = atoi(param_str_value); /* dec */
}
for(i = 0; i < loc_param_num; i++)
{
if (strcmp(loc_parameter_table[i].param_name, param_name) == 0 &&
loc_parameter_table[i].param_ptr)
{
switch (loc_parameter_table[i].param_type)
{
case 's':
if (strcmp(param_str_value, "NULL") == 0)
{
*((char*)loc_parameter_table[i].param_ptr) = '\0';
}
else {
strlcpy((char*) loc_parameter_table[i].param_ptr,
param_str_value,
LOC_MAX_PARAM_STRING + 1);
}
/* Log INI values */
LOC_LOGD("loc_read_gps_conf: PARAM %s = %s\n", param_name, (char*)loc_parameter_table[i].param_ptr);
break;
case 'n':
*((int *)loc_parameter_table[i].param_ptr) = param_value;
/* Log INI values */
LOC_LOGD("loc_read_gps_conf: PARAM %s = %d\n", param_name, param_value);
break;
default:
LOC_LOGE("loc_read_gps_conf: PARAM %s parameter type must be n or n", param_name);
}
}
}
}
fclose(gps_conf_fp);
}
int main(int argc, char *argv[])
{
if(argc != 3)
{
printf("USAGE: EXE IP PORT\n");
exit(-1);
}
//init
int fd_server, fd_file;
MSG send_msg, recv_msg, msg;
SA server_addr;
fd_server = socket(AF_INET, SOCK_STREAM, 0);
if(fd_server == -1)
{
perror("socket");
exit(-1);
}
bzero(&server_addr, sizeof(SA));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(atoi(argv[2]));
server_addr.sin_addr.s_addr = inet_addr(argv[1]);
if(-1 == connect(fd_server, (struct sockaddr*)&server_addr, sizeof(SA)))
{
perror("connect");
close(fd_server);
exit(-1);
}
while(bzero(&msg, sizeof(MSG)), fgets(msg.s_buf, sizeof(MSG), stdin) != NULL)
{
printf("begin\n");
if(msg.s_buf[0] == '\n')
{
continue;
}
trim_space(msg.s_buf);
msg.s_len = strlen(msg.s_buf);
send(fd_server, &msg, msg.s_len + MSG_LEN, 0);
//gets
if(strncmp(msg.s_buf, "gets", 4) == 0)
{
char file_name[256];
int file_pos = 5;
while(bzero(file_name, 256), sscanf(msg.s_buf + file_pos, "%s", file_name) == 1)
{
file_pos += strlen(file_name) + 1;
fd_file = open(file_name, O_WRONLY | O_CREAT, 0666);
while(1)
{
bzero(&recv_msg, sizeof(MSG));
recv(fd_server, &recv_msg, MSG_LEN, 0);
if(recv_msg.s_len > 0)
{
recv(fd_server, recv_msg.s_buf, recv_msg.s_len, 0);
write(fd_file, recv_msg.s_buf, recv_msg.s_len);
}
else
{
printf("file >> [%s] download done!\n", msg.s_buf + 5);
break;
}
}
close(fd_file);
}
}
//puts
else if(strncmp(msg.s_buf, "puts", 4) == 0)
{
char file_name[256];
int file_pos = 5;
while(bzero(file_name, 256), sscanf(msg.s_buf + file_pos, "%s", file_name) == 1)
{
file_pos += strlen(file_name) + 1;
fd_file = open(file_name, O_RDONLY);
while(bzero(&send_msg, sizeof(MSG)), (send_msg.s_len = read(fd_file, send_msg.s_buf, MSG_SIZE)) > 0)
{
send(fd_server, &send_msg, send_msg.s_len + MSG_LEN, 0);
}
send_msg.s_len = 0;
send(fd_server, &send_msg, send_msg.s_len + MSG_LEN, 0);
printf("file >> [%s] upload done!\n", msg.s_buf + 5);
close(fd_file);
}
}
//ls cd remove wrong
else
{
system("clear");
while(1)
{
bzero(&recv_msg, sizeof(MSG));
recv(fd_server, &recv_msg, MSG_LEN, 0);
if(recv_msg.s_len > 0)
{
recv(fd_server, recv_msg.s_buf, recv_msg.s_len, 0);
printf("%s\n", recv_msg.s_buf);
}
else
{
break;
}
}
}
}
msg.s_len = 0;
send(fd_server, &send_msg, send_msg.s_len + MSG_LEN, 0);
return 0;
}
/**
* tests all helper functions
*/
static char * test_helpers() {
Logo input;
char tmp[VAR_LENGTH+1], str[LINE_LENGTH];
char * trimmed;
int ret, i;
float output;
printf("Testing %s\n", __FUNCTION__);
/* test get_var() */
input = create_logo(0);
/* this is essentially set_var("A", input->vars, 10); */
input->vars[0].data = 10;
input->vars[0].used = 1;
/* try to get A */
ret = get_var("A", input->vars, &output);
mu_assert("error, ret != 0", ret == 0);
mu_assert("error, A != 10", output == 10);
/* try to get B which is not initialised */
ret = get_var("B", input->vars, &output);
mu_assert("error, ret != VAR_ERR", ret == VAR_ERR);
/* test set_var() */
set_var("A", input->vars, 20);
set_var("B", input->vars, 40);
mu_assert("error, A != 20", input->vars[0].data == 20.0);
mu_assert("error, B != 40", input->vars[1].data == 40.0);
/* setting the var should have flagged this var as used */
mu_assert("error, B is not initialised", input->vars[0].used == 1);
/* test is_var() from A-Z */
for (i='A'; i<='Z'; i++) {
tmp[0] = i;
tmp[1] = '\0';
ret = is_var(tmp);
mu_assert("error, ret != 1", ret == 1);
}
/* test bogus inputs */
/* small letter */
tmp[0] = 'a';
ret = is_var(tmp);
mu_assert("error, ret != 0", ret == 0);
/* number */
tmp[0] = '1';
ret = is_var(tmp);
mu_assert("error, ret != 0", ret == 0);
/* test is_op */
tmp[0] = '+';
ret = is_op(tmp);
mu_assert("error, ret != 1", ret == 1);
tmp[0] = '-';
ret = is_op(tmp);
mu_assert("error, ret != 1", ret == 1);
tmp[0] = '*';
ret = is_op(tmp);
mu_assert("error, ret != 1", ret == 1);
tmp[0] = '/';
ret = is_op(tmp);
mu_assert("error, ret != 1", ret == 1);
/* test bogus inputs */
tmp[0] = '=';
ret = is_op(tmp);
mu_assert("error, ret != 0", ret == 0);
tmp[0] = '^';
ret = is_op(tmp);
mu_assert("error, ret != 0", ret == 0);
tmp[0] = '$';
ret = is_op(tmp);
mu_assert("error, ret != 0", ret == 0);
/* test trim_space() */
strcpy(str, "\t\tFD 30 \t\t ");
trimmed = trim_space(str);
mu_assert("error, trimmed != \"FD 30\"", strsame(trimmed, "FD 30"));
strcpy(str, " \t \tDO A FROM 1 TO 8 { \t\t ");
trimmed = trim_space(str);
mu_assert("error, trimmed != \"DO A FROM 1 TO 8 {\"", strsame(trimmed, "DO A FROM 1 TO 8 {"));
tear_down(input);
return 0;
}
/*===========================================================================
FUNCTION loc_read_conf
DESCRIPTION
Reads the specified configuration file and sets defined values based on
the passed in configuration table. This table maps strings to values to
set along with the type of each of these values.
PARAMETERS:
conf_file_name: configuration file to read
config_table: table definition of strings to places to store information
table_length: length of the configuration table
DEPENDENCIES
N/A
RETURN VALUE
None
SIDE EFFECTS
N/A
===========================================================================*/
void loc_read_conf(const char* conf_file_name, loc_param_s_type* config_table, uint32_t table_length)
{
FILE *gps_conf_fp = NULL;
char input_buf[LOC_MAX_PARAM_LINE]; /* declare a char array */
char *lasts;
loc_param_v_type config_value;
uint32_t i;
if((gps_conf_fp = fopen(conf_file_name, "r")) != NULL)
{
LOC_LOGD("%s: using %s", __FUNCTION__, conf_file_name);
}
else
{
LOC_LOGW("%s: no %s file found", __FUNCTION__, conf_file_name);
loc_logger_init(DEBUG_LEVEL, TIMESTAMP);
return; /* no parameter file */
}
/* Clear all validity bits */
for(i = 0; NULL != config_table && i < table_length; i++)
{
if(NULL != config_table[i].param_set)
{
*(config_table[i].param_set) = 0;
}
}
while(fgets(input_buf, LOC_MAX_PARAM_LINE, gps_conf_fp) != NULL)
{
memset(&config_value, 0, sizeof(config_value));
/* Separate variable and value */
config_value.param_name = strtok_r(input_buf, "=", &lasts);
if (config_value.param_name == NULL) continue; /* skip lines that do not contain "=" */
config_value.param_str_value = strtok_r(NULL, "=", &lasts);
if (config_value.param_str_value == NULL) continue; /* skip lines that do not contain two operands */
/* Trim leading and trailing spaces */
trim_space(config_value.param_name);
trim_space(config_value.param_str_value);
/* Parse numerical value */
if (config_value.param_str_value[0] == '0' && tolower(config_value.param_str_value[1]) == 'x')
{
/* hex */
config_value.param_int_value = (int) strtol(&config_value.param_str_value[2], (char**) NULL, 16);
}
else {
config_value.param_double_value = (double) atof(config_value.param_str_value); /* float */
config_value.param_int_value = atoi(config_value.param_str_value); /* dec */
}
for(i = 0; NULL != config_table && i < table_length; i++)
{
loc_set_config_entry(&config_table[i], &config_value);
}
for(i = 0; i < loc_param_num; i++)
{
loc_set_config_entry(&loc_parameter_table[i], &config_value);
}
}
fclose(gps_conf_fp);
/* Initialize logging mechanism with parsed data */
loc_logger_init(DEBUG_LEVEL, TIMESTAMP);
}
