int main(int argc, char *argv[]){ write_uart_error_ptr = &write_uart_error; //initialize the function pointer to write error write_udp_error_ptr = &write_udp_error; write_decode_error_ptr = &write_decode_error; write_log_error_ptr = &write_log_error; //parse arguments if(argc == 4){ //first argument is always name of program or empty string connection.server_ip=argv[1]; connection.port_number_lisa_to_pc=atoi(argv[2]); connection.port_number_pc_to_lisa=atoi(argv[3]); }else{ printf("wrong parameters: server ip - send port number - receive port number\n"); exit(EXIT_FAILURE); } //init log (mount sd card if necessary) int err = init_log(); LOG_err_handler(err,write_log_error_ptr); if(err != LOG_ERR_NONE){ exit(EXIT_FAILURE); //mounting SD card failed } enable_ptp(); #if LOGGING > 0 //init circular data log buffers cbInit(cb_read_lisa, CBSIZE); cbInit(cb_write_lisa, CBSIZE); cbInit(cb_read_ground, CBSIZE); cbInit(cb_write_ground, CBSIZE); #endif err = serial_port_setup(); UART_err_handler(err,write_uart_error_ptr); if(err != UART_ERR_NONE){ exit(EXIT_FAILURE); } //thread variables pthread_t thread_lisa_to_pc,thread_data_logging_lisa,thread_data_logging_ground; //create a second thread which executes lisa_to_pc if(pthread_create(&thread_lisa_to_pc, NULL, lisa_to_pc,NULL)) { error_write(FILENAME,"error creating lisa thread"); exit(EXIT_FAILURE); } #if LOGGING > 0 //create a third thread which executes data_logging_lisa if(pthread_create(&thread_data_logging_lisa, NULL, data_logging_lisa,NULL)) { error_write(FILENAME,"error creating lisa logging thread"); exit(EXIT_FAILURE); } //create a fourth thread which executes data_logging_groundstation if(pthread_create(&thread_data_logging_ground, NULL, data_logging_groundstation,NULL)) { error_write(FILENAME,"error creating groundstation logging thread"); exit(EXIT_FAILURE); } #endif /*-------------------------START OF FIRST THREAD: PC TO LISA------------------------*/ static UDP udp_server; uint8_t input_stream[OUTPUT_BUFFER]; ElemType cb_elem = {0}; //init the data decode pointers init_decoding(); UDP_err_handler(openUDPServerSocket(&udp_server,connection.port_number_pc_to_lisa,UDP_SOCKET_TIMEOUT),write_udp_error_ptr); while(1){ //1. retreive UDP data form PC from ethernet port. err=receiveUDPServerData(&udp_server,(void *)&input_stream,sizeof(input_stream)); //blocking !!! UDP_err_handler(err,write_udp_error_ptr); if(err==UDP_ERR_NONE){ #if LOGGING > 0 if(!cbIsFull(cb_write_ground)){ memcpy (&cb_elem.value, &input_stream, sizeof(input_stream)); cbWrite(cb_write_ground, &cb_elem); }else{ if(reading_flag_ground==0){ switch_cb_ground_pointers(); }else{ printf("GROUND WRITE WAS NOT READY \n"); } } #endif int new_length = strip_timestamp(input_stream); //lisa expects a package without a timestamp UART_err_handler(serial_port_write(input_stream,new_length),write_uart_error_ptr); } } UART_err_handler(serial_port_close(),write_uart_error_ptr); UDP_err_handler(closeUDPServerSocket(&udp_server),write_udp_error_ptr); /*------------------------END OF FIRST THREAD------------------------*/ //wait for the second thread to finish if(pthread_join(thread_lisa_to_pc, NULL)) { error_write(FILENAME,"error joining thread_lisa_to_pc"); } #if LOGGING > 0 //wait for the third thread to finish if(pthread_join(thread_data_logging_lisa, NULL)) { error_write(FILENAME,"error joining thread_data_logging_lisa"); } //wait for the fourth thread to finish if(pthread_join(thread_data_logging_ground, NULL)) { error_write(FILENAME,"error joining thread_data_logging_ground"); } //free circular buffers cbFree(cb_read_lisa); cbFree(cb_write_lisa); cbFree(cb_read_ground); cbFree(cb_write_ground); #endif return 0; }
static int match_one_pattern(struct grep_pat *p, char *bol, char *eol, enum grep_context ctx, regmatch_t *pmatch, int eflags) { int hit = 0; int saved_ch = 0; const char *start = bol; if ((p->token != GREP_PATTERN) && ((p->token == GREP_PATTERN_HEAD) != (ctx == GREP_CONTEXT_HEAD))) return 0; if (p->token == GREP_PATTERN_HEAD) { const char *field; size_t len; assert(p->field < ARRAY_SIZE(header_field)); field = header_field[p->field].field; len = header_field[p->field].len; if (strncmp(bol, field, len)) return 0; bol += len; saved_ch = strip_timestamp(bol, &eol); } again: if (p->fixed) hit = !fixmatch(p->pattern, bol, p->ignore_case, pmatch); else hit = !regexec(&p->regexp, bol, 1, pmatch, eflags); if (hit && p->word_regexp) { if ((pmatch[0].rm_so < 0) || (eol - bol) < pmatch[0].rm_so || (pmatch[0].rm_eo < 0) || (eol - bol) < pmatch[0].rm_eo) die("regexp returned nonsense"); /* Match beginning must be either beginning of the * line, or at word boundary (i.e. the last char must * not be a word char). Similarly, match end must be * either end of the line, or at word boundary * (i.e. the next char must not be a word char). */ if ( ((pmatch[0].rm_so == 0) || !word_char(bol[pmatch[0].rm_so-1])) && ((pmatch[0].rm_eo == (eol-bol)) || !word_char(bol[pmatch[0].rm_eo])) ) ; else hit = 0; /* Words consist of at least one character. */ if (pmatch->rm_so == pmatch->rm_eo) hit = 0; if (!hit && pmatch[0].rm_so + bol + 1 < eol) { /* There could be more than one match on the * line, and the first match might not be * strict word match. But later ones could be! * Forward to the next possible start, i.e. the * next position following a non-word char. */ bol = pmatch[0].rm_so + bol + 1; while (word_char(bol[-1]) && bol < eol) bol++; eflags |= REG_NOTBOL; if (bol < eol) goto again; } } if (p->token == GREP_PATTERN_HEAD && saved_ch) *eol = saved_ch; if (hit) { pmatch[0].rm_so += bol - start; pmatch[0].rm_eo += bol - start; } return hit; }
static int match_one_pattern(struct grep_opt *opt, struct grep_pat *p, char *bol, char *eol, enum grep_context ctx) { int hit = 0; int at_true_bol = 1; int saved_ch = 0; regmatch_t pmatch[10]; if ((p->token != GREP_PATTERN) && ((p->token == GREP_PATTERN_HEAD) != (ctx == GREP_CONTEXT_HEAD))) return 0; if (p->token == GREP_PATTERN_HEAD) { const char *field; size_t len; assert(p->field < ARRAY_SIZE(header_field)); field = header_field[p->field].field; len = header_field[p->field].len; if (strncmp(bol, field, len)) return 0; bol += len; saved_ch = strip_timestamp(bol, &eol); } again: if (!opt->fixed) { regex_t *exp = &p->regexp; hit = !regexec(exp, bol, ARRAY_SIZE(pmatch), pmatch, 0); } else { hit = !fixmatch(p->pattern, bol, pmatch); } if (hit && opt->word_regexp) { if ((pmatch[0].rm_so < 0) || (eol - bol) <= pmatch[0].rm_so || (pmatch[0].rm_eo < 0) || (eol - bol) < pmatch[0].rm_eo) die("regexp returned nonsense"); /* Match beginning must be either beginning of the * line, or at word boundary (i.e. the last char must * not be a word char). Similarly, match end must be * either end of the line, or at word boundary * (i.e. the next char must not be a word char). */ if ( ((pmatch[0].rm_so == 0 && at_true_bol) || !word_char(bol[pmatch[0].rm_so-1])) && ((pmatch[0].rm_eo == (eol-bol)) || !word_char(bol[pmatch[0].rm_eo])) ) ; else hit = 0; if (!hit && pmatch[0].rm_so + bol + 1 < eol) { /* There could be more than one match on the * line, and the first match might not be * strict word match. But later ones could be! */ bol = pmatch[0].rm_so + bol + 1; at_true_bol = 0; goto again; } } if (p->token == GREP_PATTERN_HEAD && saved_ch) *eol = saved_ch; return hit; }