int GPIORelaisController::openMap() { int res = 1; info_printf("GPIORelaisController::openMap\n"); gpioregs = (char *) mmap_device_memory( 0, gpioPortLen, PROT_READ|PROT_WRITE|PROT_NOCACHE, 0, gpioPortBase ); if ( gpioregs == MAP_FAILED ) { info_printf( "mmap_device_memory for physical address %X and length %X failed\n", gpioPortBase, gpioPortLen ); res = 0; } /* memfd = open("/dev/mem", O_RDWR|O_SYNC); if( memfd == NULL ) { info_printf("Error while opening the mem file.\n"); gpioregs = MAP_FAILED; res = 0; } if (res == 0 ) { gpioregs = (char *)mmap(0, mapLen, PROT_READ|PROT_WRITE, MAP_SHARED, memfd, mapBase); if (gpioregs == MAP_FAILED) { info_printf("Error while mmap.\n"); res = 0; } // info_printf("gpioregs mapped\n"); } // usleep(500000); */ return res; }
int main(int argc, const char * const *argv) { // if VALGRIND testing is enabled, we have to call ourselves with valgrind checking const char *valgrind = getenv("VALGRIND_TESTS"); if (!valgrind || !*valgrind || !strcmp(valgrind, "0")) { // fallthrough } else if (!strcmp(valgrind, "1")) { char cmd[strlen(argv[0]) + 256]; snprintf(cmd, sizeof(cmd), "VALGRIND_TESTS=\"\" valgrind --error-exitcode=301 --leak-check=yes --show-reachable=yes --track-origins=yes %s", argv[0]); return system(cmd) != 0; } else { char cmd[strlen(valgrind) + strlen(argv[0]) + 32]; snprintf(cmd, sizeof(cmd), "VALGRIND_TESTS="" %s %s", valgrind, argv[0]); return system(cmd) != 0; } init(argc, argv); // allows us to test with options (e.g. with --debug) srand((unsigned int) time(NULL)); // testing basic library functionality test_buffer(); test_buffer_printf(); test_utils(); test_strcasecmp_ascii(); test_vector(); test_stringmap(); if (failed) { info_printf("ERROR: %d out of %d basic tests failed\n", failed, ok + failed); info_printf("This may completely break Mget functionality !!!\n"); return 1; } test_iri_parse(); test_iri_relative_to_absolute(); test_iri_compare(); test_parser(); test_cookies(); test_hsts(); test_parse_challenge(); selftest_options() ? failed++ : ok++; deinit(); // free resources allocated by init() if (failed) { info_printf("Summary: %d out of %d tests failed\n", failed, ok + failed); return 1; } info_printf("Summary: All %d tests passed\n", ok + failed); return 0; }
static void _test_buffer(mget_buffer_t *buf, const char *name) { char test[256]; int it; for (it = 0; it < (int)sizeof(test)-1; it++) { test[it] = 'a' + it % 26; test[it + 1] = 0; mget_buffer_strcpy(buf, test); mget_buffer_strcat(buf, test); if (!strncmp(buf->data, test, it + 1) && !strncmp(buf->data + it + 1, test, it + 1)) { ok++; } else { failed++; info_printf("test_buffer.1 '%s': [%d] got %s (expected %s%s)\n", name, it, buf->data, test, test); } mget_buffer_memcpy(buf, test, it + 1); mget_buffer_memcat(buf, test, it + 1); if (!strncmp(buf->data, test, it + 1) && !strncmp(buf->data + it + 1, test, it + 1)) { ok++; } else { failed++; info_printf("test_buffer.2 '%s': [%d] got %s (expected %s%s)\n", name, it, buf->data, test, test); } mget_buffer_printf(buf, "%s%s", test, test); if (!strncmp(buf->data, test, it + 1) && !strncmp(buf->data + it + 1, test, it + 1)) { ok++; } else { failed++; info_printf("test_buffer.3 '%s': [%d] got %s (expected %s%s)\n", name, it, buf->data, test, test); } mget_buffer_printf(buf, "%s", test); mget_buffer_printf_append(buf, "%s", test); if (!strncmp(buf->data, test, it + 1) && !strncmp(buf->data + it + 1, test, it + 1)) { ok++; } else { failed++; info_printf("test_buffer.4 '%s': [%d] got %s (expected %s%s)\n", name, it, buf->data, test, test); } } }
// Callback function, called from CSS parser for each @charset found. static void css_parse_encoding(void *context, const char *encoding, size_t len) { struct css_context *ctx = context; // take only the first @charset rule if (!ctx->encoding_allocated && mget_strncasecmp(ctx->encoding, encoding, len)) { if (ctx->encoding) info_printf("Encoding changed from '%s' to '%.*s'\n", ctx->encoding, (int)len, encoding); else info_printf("Encoding set to '%.*s'\n", (int)len, encoding); ctx->encoding = strndup(encoding, len); ctx->encoding_allocated = 1; } }
NonPosixTimer::NonPosixTimer() { info_printf("NonPosixTimer creator\n"); stopCond = 0; step = 0; memset(timerCnt,0,sizeof(timerCnt)); }
void AppInit_TCPIP (void) { #if EMAC_CFG_MAC_ADDR_SEL == EMAC_MAC_ADDR_SEL_CFG NetIF_MAC_Addr[0] = 0x00; NetIF_MAC_Addr[1] = 0x50; NetIF_MAC_Addr[2] = 0xC2; NetIF_MAC_Addr[3] = 0x25; NetIF_MAC_Addr[4] = 0x60; NetIF_MAC_Addr[5] = 0x01; #endif #if uC_TTCP_MODULE > 0 BSP_USART_Init(TTCP_COMM_SEL, 38400); #endif err = Net_Init(); ip = NetASCII_Str_to_IP((CPU_CHAR *) ownIPAddress, &err); msk = NetASCII_Str_to_IP((CPU_CHAR *)"255.255.255.0", &err); gateway = NetASCII_Str_to_IP((CPU_CHAR *)"192.168.1.1", &err); err = NetIP_CfgAddrThisHost(ip, msk); err = NetIP_CfgAddrDfltGateway(gateway); #if uC_TTCP_MODULE > 0 TTCP_Init(); #endif info_printf("tcp/ip network initialized ...\n"); }
int main (void) { #if (OS_TASK_NAME_SIZE > 7) && (OS_TASK_STAT_EN > 0) CPU_INT08U err; #endif CPU_IntDis(); /* Disable all interrupts until we are ready to accept them */ OSInit(); BSP_Init(); init_err_printf(); OSTaskCreateExt(AppTaskStart, (void *)0, (OS_STK *)&AppTaskStartStk[APP_TASK_START_STK_SIZE - 1], APP_TASK_START_PRIO, APP_TASK_START_PRIO, (OS_STK *)&AppTaskStartStk[0], APP_TASK_START_STK_SIZE, (void *)0, OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR); #if (OS_TASK_NAME_SIZE > 7) && (OS_TASK_STAT_EN > 0) OSTaskNameSet(APP_TASK_START_PRIO, (CPU_CHAR *)"Startup", &err); #endif OSStart(); info_printf("EVK1100_Interface to cyclone-III rustlight fpga starting\n"); return (0); }
static void test_hsts(void) { static const struct hsts_db_data { const char * host; int port; const char * hsts_params; } hsts_db_data[] = { { "www.example.com", 443, "max-age=14400; includeSubDomains" }, { "www.example2.com", 443, "max-age=14400" }, { "www.example2.com", 443, "max-age=0" }, // this removes the previous entry }; static const struct hsts_data { const char * host; int port; int result; } hsts_data[] = { { "www.example.com", 443, 1 }, // exact match { "ftp.example.com", 443, 0 }, { "example.com", 443, 0 }, { "sub.www.example.com", 443, 1 }, // subdomain { "sub1.sub2.www.example.com", 443, 1 }, // subdomain { "www.example2.com", 443, 0 }, // entry should have been removed due to maxage=0 { "www.example.com", 80, 1 }, // default port { "www.example.com", 8080, 0 }, // wrong port }; wget_hsts_db_t *hsts_db = wget_hsts_db_init(NULL); time_t maxage; char include_subdomains; int n; // fill HSTS database with values for (unsigned it = 0; it < countof(hsts_db_data); it++) { const struct hsts_db_data *t = &hsts_db_data[it]; wget_http_parse_strict_transport_security(t->hsts_params, &maxage, &include_subdomains); wget_hsts_db_add(hsts_db, wget_hsts_new(t->host, t->port, maxage, include_subdomains)); } // check HSTS database with values for (unsigned it = 0; it < countof(hsts_data); it++) { const struct hsts_data *t = &hsts_data[it]; n = wget_hsts_host_match(hsts_db, t->host, t->port); if (n == t->result) ok++; else { failed++; info_printf("Failed [%u]: wget_hsts_host_match(%s,%d) -> %d (expected %d)\n", it, t->host, t->port, n, t->result); } } wget_hsts_db_free(&hsts_db); }
GPIORelaisController::GPIORelaisController() { info_printf("constructur GPIORelaisController\n"); allRelaisBits = allRelaisValue(); if (openMap()) { setOffAllRelais(); } }
void infohelper_print_progress(char *msg, float cval, float maxval) { unsigned int cur, cnt; if(cval == 0) { beat = 0; } cur = (35 / maxval) * cval; cnt = 35-cur; if(msg) { info_printf(1, "%s: [", msg); } else { info_printf(1, "["); } while(cur--) { info_printf(101, "*"); } if(cnt) { if(cval) { info_printf(101, "%c",heartbeat[beat]); } else { info_printf(101, " "); } } else { info_printf(101, "*"); } while(cnt--) { info_printf(101, " "); } info_printf(101, "\b]\r"); fflush(stdout); beat++; beat &= 0x07; }
// convert the pointed string to a right ascension value; if a conversion cannot be done, // the value is unchanged and -1 is returned int scan_ra(double *d, char *val) { int ret; double v; ret = dms_to_degrees(val, &v); if (!ret) { return -1; } if (v < 0) { info_printf("RA value is negative, ignoring sign\n"); v = -v; } if (v > 24.0) { info_printf("RA value is too large, ignoring\n"); return -1; } *d = v; return 0; }
int GPIORelaisController::closeMap() { int res = 0; info_printf("GPIORelaisController::closeMap()\n"); // if (munmap_device_memory( gpioPortBase, gpioPortLen ) == -1 ) { ??? if (munmap_device_memory( gpioregs, gpioPortLen ) == -1 ) { info_printf("GPIORelaisController::closeMap: munmap_device_memory failed \n"); } /* if ( munmap(gpioregs, mapLen) < 0) { printf("munmap() error"); res = 1; } // printf("gioregs unmapped\n"); close(memfd); */ return res; }
void NonPosixTimer::stop() { // DWORD tmOut; info_printf("\nstop NonPosixTimer\n"); setStopCond(); /* tmOut = */ pthread_join(nptThread,NULL); // pn 22. sept 12, // timeout would be desirable, but not possible via join (timedjoin), seems not be supported // in the library, according to pthread.h. Could be implemented by slowly polling for // a thread-terminated-variable with max counter condition. Or with a call to // pthread_cond_timedwait when waiting for a thread terminated condition // currently left this point open for later implementation info_printf("NonPosixTimer threadMethod stopped\n"); }
static void test_iri_compare(void) { static const struct iri_test_data { const char *url1, *url2; int result; } test_data[] = { { "http://abc.com", "http://abc.com/", -1}, // different, some web servers redirect ... to .../ due to normalization issues { "http://abc.com", "http://abc.com:", 0}, { "http://abc.com", "http://abc.com:/", -1}, { "http://abc.com", "http://abc.com:80/", -1}, { "http://abc.com", "http://abc.com:80//", -1}, // { "http://äöü.com", "http://ÄÖÜ.com:80//", 0}, { "http://abc.com:80/~smith/home.html", "http://abc.com/~smith/home.html", 0}, { "http://abc.com:80/~smith/home.html", "http://ABC.com/~smith/home.html", 0}, { "http://abc.com:80/~smith/home.html", "http://ABC.com/%7Esmith/home.html", 0}, { "http://abc.com:80/~smith/home.html", "http://ABC.com/%7esmith/home.html", 0}, { "http://ABC.com/%7esmith/home.html", "http://ABC.com/%7Esmith/home.html", 0}, { "http://ABC.com/%7esmith/home.html", "http://ACB.com/%7Esmith/home.html", -1} }; unsigned it; int n; for (it = 0; it < countof(test_data); it++) { const struct iri_test_data *t = &test_data[it]; mget_iri_t *iri1 = mget_iri_parse(t->url1, "utf-8"); mget_iri_t *iri2 = mget_iri_parse(t->url2, "utf-8"); n = mget_iri_compare(iri1, iri2); if (n < -1) n = -1; else if (n > 1) n = 1; if (n == t->result) ok++; else { failed++; info_printf("Failed [%u]: compare(%s,%s) -> %d (expected %d)\n", it, t->url1, t->url2, n, t->result); printf(" display %s / %s\n", iri1->display, iri2->display); printf(" scheme %s / %s\n", iri1->scheme, iri2->scheme); printf(" user %s / %s\n", iri1->userinfo, iri2->userinfo); printf(" host %s / %s\n", iri1->host, iri2->host); printf(" port %s / %s\n", iri1->port, iri2->port); printf(" path %s / %s\n", iri1->path, iri2->path); printf(" query %s / %s\n", iri1->query, iri2->query); printf(" fragment %s / %s\n", iri1->fragment, iri2->fragment); printf("\n"); } mget_iri_free(&iri2); mget_iri_free(&iri1); } }
void GPIORelaisController::testMethod() { int cnt1; info_printf("GPIORelaisController::testMethod()\n"); for (cnt1 = 0; cnt1 < 100; ++ cnt1) { // printf("step %i\n",cnt1); setMultipleRelaisOn(5); sleep(4); setMultipleRelaisOn(0); sleep(1); setMultipleRelaisOn(5); sleep(1); setMultipleRelaisOn(0); sleep(1); setMultipleRelaisOn(4); sleep(1); setMultipleRelaisOn(0); sleep(1); setMultipleRelaisOn(3); sleep(1); setMultipleRelaisOn(0); sleep(1); setMultipleRelaisOn(2); sleep(1); setMultipleRelaisOn(0); sleep(1); setMultipleRelaisOn(1); sleep(1); setMultipleRelaisOn(0); sleep(1); setMultipleRelaisOn(0); sleep(3); } info_printf("END GPIORelaisController::testMethod()\n"); }
int mget_cookie_db_save(mget_cookie_db_t *cookie_db, const char *fname, int keep_session_cookies) { FILE *fp; int it, ret = -1; time_t now = time(NULL); if (!cookie_db || !fname) return -1; info_printf(_("saving cookies to '%s'\n"), fname); if ((fp = fopen(fname, "w"))) { fputs("# HTTP cookie file\n", fp); fputs("#Generated by Mget " PACKAGE_VERSION ". Edit at your own risk.\n\n", fp); mget_thread_mutex_lock(&cookie_db->mutex); for (it = 0; it < mget_vector_size(cookie_db->cookies) && !ferror(fp); it++) { mget_cookie_t *cookie = mget_vector_get(cookie_db->cookies, it); if (cookie->persistent) { if (cookie->expires < now) continue; } else if (!keep_session_cookies) continue; fprintf(fp, "%s%s%s\t%s\t%s\t%s\t%"PRId64"\t%s\t%s\n", cookie->http_only ? "#HttpOnly_" : "", cookie->domain_dot ? "." : "", // compatibility, irrelevant since RFC 6562 cookie->domain, cookie->host_only ? "FALSE" : "TRUE", cookie->path, cookie->secure_only ? "TRUE" : "FALSE", (int64_t)cookie->expires, cookie->name, cookie->value); } mget_thread_mutex_unlock(&cookie_db->mutex); if (!ferror(fp)) ret = 0; if (fclose(fp)) ret = -1; if (ret) error_printf(_("Failed to write to cookie file '%s' (%d)\n"), fname, errno); } else error_printf(_("Failed to open cookie file '%s' (%d)\n"), fname, errno); return ret; }
static void test_hashing(void) { static const struct test_data { const char * text; const char * result; int algo; } test_data[] = { { "moin", "06a998cdd13c50b7875775d4e7e9fa74", WGET_DIGTYPE_MD5 }, { "moin", "ba3cffcc93a92e08f82c33c55d887666fdf364ae", WGET_DIGTYPE_SHA1 }, { "moin", "2500d0ed4d0ea1b3ea9f7f57a5f16c2fba8ad15d05d3c057d42f9796f1250169", WGET_DIGTYPE_SHA256 }, { "moin", "e3ab1c142d6136fd938c810d13deaf47ccdb176687fab916611302ceb6a89787f45fdda2df544fec4f5a9a2a40916f316fcdf57bc27b5b757b7598da24c7c4c4", WGET_DIGTYPE_SHA512 }, }; unsigned char digest[64]; char digest_hex[sizeof(digest) * 2 + 1]; int rc; for (unsigned it = 0; it < countof(test_data); it++) { const struct test_data *t = &test_data[it]; if ((rc = wget_hash_fast(t->algo, t->text, strlen(t->text), digest)) == 0) { int len = wget_hash_get_len(t->algo); wget_memtohex(digest, len, digest_hex, len * 2 + 1); if (!strcmp(digest_hex, t->result)) ok++; else { failed++; info_printf("Failed [%u]: wget_hash_fast(%s,%d) -> %s (expected %s)\n", it, t->text, t->algo, digest_hex, t->result); } } else { failed++; info_printf("Failed [%u]: wget_hash_fast(%s,%d) failed with %d\n", it, t->text, t->algo, rc); } } }
/** * It should take care of destroying the thread, the session or * leave it to the shutdown thread. */ void Server::end_session(uint64_t session_id, int code) { if (shutting_down) return; Mutex::Locker l(open_sessions_mutex); if (shutting_down) return; shared_ptr<Session> session = open_sessions[session_id]; pthread_detach(session->get_thread()); open_sessions.erase(session_id); info_printf(err_cons, "Session %d ended with code %d (%s), working sessions left: %d", (int)session_id, (int)code, SBQLstrerror(code).c_str(), (int)get_sessions_count()); }
void * NonPosixTimer::nonPosixTimerThreadMethod(void * parm) { int cnt; NonPosixTimer* lpTimer = (NonPosixTimer*) parm; lpTimer->step = 0; info_printf("\nNonPosixTimer::nonPosixTimerThreadMethod Started\n"); while (!lpTimer->isStopCondSet()) { ++ lpTimer->step; for (cnt = 0; cnt < maxTimers; ++ cnt){ if (lpTimer->isTimerTodo(cnt)){ lpTimer->onTimer(cnt); } } sleep(1); } info_printf("\nNonPosixTimer::nonPosixTimerThreadMethod Returning\n"); return 0; }
static void test_parser(void) { DIR *dirp; struct dirent *dp; const char *ext; char fname[128]; int xml = 0, html = 0, css = 0; // test the XML / HTML parser, you should start the test with valgrind // to detect memory faults if ((dirp = opendir(SRCDIR "/files")) != NULL) { while ((dp = readdir(dirp)) != NULL) { if (*dp->d_name == '.') continue; if ((ext = strrchr(dp->d_name, '.'))) { snprintf(fname, sizeof(fname), SRCDIR "/files/%s", dp->d_name); if (!mget_strcasecmp_ascii(ext, ".xml")) { info_printf("parsing %s\n", fname); mget_xml_parse_file(fname, NULL, NULL, 0); xml++; } /* else if (!mget_strcasecmp_ascii(ext, ".html")) { info_printf("parsing %s\n", fname); mget_html_parse_file(fname, NULL, NULL, 0); html++; } else if (!mget_strcasecmp_ascii(ext, ".css")) { info_printf("parsing %s\n", fname); mget_css_parse_file(fname, _css_dump_uri, _css_dump_charset, NULL); css++; } */ } } closedir(dirp); } info_printf("%d XML, %d HTML and %d CSS files parsed\n", xml, html, css); }
void Server::main_loop() { sigset_t sigset_tmpl, sigset; pthread_sigmask(0, NULL, &sigset_tmpl); sigaddset(&sigset_tmpl, SIGUSR1); sigset = sigset_tmpl; auto_ptr<DataStream> stream; try{ info_printf(err_cons, "Waiting for connections."); while (!shutting_down){ auto_ptr<DataStream> stream = server.accept(sigset, shutting_down); Mutex::Locker l(open_sessions_mutex); if (!shutting_down && get_sessions_count() < get_config_max_sessions()){ try{ auto_ptr<PackageStream> pstream(new PackageCodec(stream, get_config_max_package_size())); shared_ptr<Session> new_session(new Session(*this, pstream)); open_sessions[new_session->get_id()] = new_session; new_session->launch(); } catch (LoximException &ex) { warning_print(err_cons, "Caught exception while creating new session:"); warning_print(err_cons, ex.to_string()); } catch (...) { warning_print(err_cons, "Caught unknown exception while creating new session"); } } } } catch (OperationCancelled &ex) { //this is a normal way of exiting the server } catch (LoximException &ex){ info_print(err_cons, "Caught exception in server loop, shutting down"); debug_print(err_cons, ex.to_string()); } catch (...) { info_print(err_cons, "Caught unknown exception in server loop, shutting down"); } { Mutex::Locker l(open_sessions_mutex); shutting_down = 1; info_print(err_cons, "Quitting, telling sessions to shut down"); for (set<pair<const uint64_t, shared_ptr<Session> > >::iterator i = open_sessions.begin(); i != open_sessions.end(); i++){ i->second->shutdown(0); } } info_print(err_cons, "Joining threads"); for (set<pair<const uint64_t, shared_ptr<Session> > >::iterator i = open_sessions.begin(); i != open_sessions.end(); i++){ pthread_join(i->second->get_thread(), NULL); } open_sessions.clear(); info_print(err_cons, "Threads joined"); }
// convert the pointed string to a declination value; if a conversion cannot be done, // the value is unchanged and -1 is returned int scan_dec(double *d, char *val) { int ret; double v; ret = dms_to_degrees(val, &v); if (!ret) { return -1; } if (v > 90.0 || v < -90.0) { info_printf("DEC value is too large, ignoring\n"); return -1; } *d = v; return 0; }
static int info_draw(ToolWin *tw) { toolwin_backing(tw); /* info */ cairo_set_source_rgba(tw->ctx,0,0,0,1.0); cairo_set_font_face(tw->ctx, conf.bfont); cairo_move_to(tw->ctx, 0, 8); info_printf(tw, A_CENTER, "%.3lf sec, %.2lf KHz", spect->fft->time[mx],spect->fft->freq[my]); cairo_rel_move_to(tw->ctx,0,12); info_split_printf(tw, "Threshold:", "%.2lf", -1.0 * conf.thresh); info_split_printf(tw, "Spectrogram Floor:", "%.2lf", -1.0 * conf.spect_floor); info_split_printf(tw, "Path Length:","%.2lf", spect->pex); info_split_printf(tw, "Path Duration:","%.3lf", spect->tex); info_split_printf(tw, "Frequency Excursion:","%.3lf", spect->fex); cairo_move_to(tw->ctx, 0, 145); /* modes */ info_split_printf(tw, "Modes:",""); cairo_set_font_face(tw->ctx, conf.bfont); /* erase */ set_color(tw->ctx,RGBA_ERASE1) if (mode & MODE_ERASE) set_color(tw->ctx,RGBA_ERASE1) else cairo_set_source_rgba(tw->ctx,0.8,0.8,0.8,1.0); cairo_rectangle(tw->ctx, 10, 170, tw->w / 2.0 - 15, 20); cairo_fill_preserve(tw->ctx); cairo_set_source_rgba(tw->ctx,0,0,0,1.0); cairo_stroke(tw->ctx); cairo_text_extents(tw->ctx,"Erase",&ext); cairo_move_to(tw->ctx, tw->w / 4.0 - ext.width / 2.0, 185); cairo_set_source_rgba(tw->ctx,0,0,0,1.0); cairo_show_text(tw->ctx,"Erase"); /* crop */ if (mode & MODE_CROP) set_color(tw->ctx, RGBA_CROP) else cairo_set_source_rgba(tw->ctx,0.8,0.8,0.8,1.0); cairo_rectangle(tw->ctx, 5 + tw->w / 2.0, 170, tw->w / 2.0 - 15, 20); cairo_fill_preserve(tw->ctx); cairo_set_source_rgba(tw->ctx,0.0,0.0,0.0,1.0); cairo_stroke(tw->ctx); cairo_text_extents(tw->ctx,"Crop",&ext); cairo_move_to(tw->ctx, tw->w * 0.75 - ext.width / 2.0, 185); cairo_set_source_rgba(tw->ctx,0,0,0,1.0); cairo_show_text(tw->ctx,"Crop"); /* draw */ toolwin_draw(tw); return 0; }
static void test_striconv(void) { const char *utf8 = "abcßüäö"; char *utf16be = NULL, *utf16le = NULL, *result = NULL; size_t n; // convert utf-8 to utf-16be if (wget_memiconv("utf-8", utf8, strlen(utf8), "UTF-16BE", &utf16be, &n) || wget_memiconv("UTF-16BE", utf16be, n, "UTF-16LE", &utf16le, &n) || wget_memiconv("UTF-16LE", utf16le, n, "UTF-8", &result, &n) || strcmp(utf8, result)) { info_printf("Character conversion of '%s' failed (got '%s')\n", utf8, result); failed++; } else { ok++; } xfree(result); xfree(utf16le); xfree(utf16be); }
void startTcpipThread() { INT8U retVal = 0; retVal = OSTaskCreateExt(tcp_ip_Thread_Method, (void *)0, (OS_STK *)&tcp_ip_Thread_MethodStk[tcp_ip_Thread_Method_STK_SIZE - 1], tcp_ip_Thread_TASK_PRIO, tcp_ip_Thread_TASK_PRIO, (OS_STK *)&tcp_ip_Thread_MethodStk[0], tcp_ip_Thread_Method_STK_SIZE, (void *)0, OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR); if (retVal != OS_NO_ERR ) { err_printf("error create sec100 tcp_ip Thread\n"); } else { info_printf("tcp/ip started as %s:%d\n",ownIPAddress,UDP_SERVER_PORT); } #if (OS_TASK_NAME_SIZE > 10) OSTaskNameSet(tcp_ip_Thread_TASK_PRIO, (CPU_CHAR *)"tcp_ip", &err); #endif }
static void AppTaskStart (void *p_arg) { CPU_INT08U i; (void)p_arg; #if OS_TASK_STAT_EN > 0 OSStatInit(); /* Determine CPU capacity */ #endif #if uC_TCPIP_MODULE > 0 // AppInit_TCPIP(); #endif // initIfDipatcher(); // AppTaskCreate(); INT32U loopCnt = 0; while (1) { loopCnt ++; for (i = 1; i <= 6; i++) { LED_On(i); OSTimeDlyHMSM(0, 0, 1, 0); LED_Off(i); } for (i = 4; i <= 7; i++) { LED_On(9 - i); OSTimeDlyHMSM(0, 0, 1, 0); LED_Off(9 - i); } info_printf("AppTaskStart loopCnt: %u \n",loopCnt); } }
static void test_utils(void) { int it; unsigned char src[1]; char dst1[3], dst2[3]; for (int ndst = 1; ndst <= 3; ndst++) { for (it = 0; it <= 255; it++) { src[0] = (unsigned char) it; mget_memtohex(src, 1, dst1, ndst); snprintf(dst2, ndst, "%02x", src[0]); if (strcmp(dst1, dst2)) { info_printf("buffer_to_hex failed: '%s' instead of '%s' (ndst=%d)\n", dst1, dst2, ndst); failed++; break; } } if (it >= 256) ok++; else failed++; } }
int main(int argc, char **argv) { std::string header = "*** BRONCO v0.1 ***"; /* Read arguments */ if (argc != 2) { printf("Announce: %s --announce <path-to-file> bronco://<host>[:<port>]\n", argv[0]); printf(" Join: %s bronco://<host>[:<port>]/<content_id>\n", argv[0]); cleanup_and_exit(EXIT_FAILURE); } /* Set signal handlers */ signal(SIGINT, signal_close); signal(SIGTERM, signal_close); signal(SIGHUP, signal_close); /* Initialize ncurses */ initscr(); /* Get screen dimensions */ uint32_t maxy = 0; uint32_t maxx = 0; getmaxyx(stdscr, maxy, maxx); /* Create windows */ header_win = newwin(HEADER_HEIGHT, maxx, 0, 0); file_win = newwin(FILE_HEIGHT, maxx, HEADER_HEIGHT, 0); info_win = newwin(maxy-HEADER_HEIGHT-FILE_HEIGHT, maxx, HEADER_HEIGHT+FILE_HEIGHT, 0); /* Set ncurses options */ noecho(); curs_set(0); halfdelay(5); keypad(stdscr, TRUE); scrollok(info_win, TRUE); /* Create peer manager */ struct bronco::peermanager::peer_config c = {10, 10, 5, "localhost", bronco::peermanager::select_port()}; struct bronco::peermanager::nc_parameters p = {"bin/bronco-nc", 512, 400}; manager_ptr = new bronco::peermanager(argv[1], &c, &p, &info_printf); /* Screen update loop */ while (1) { /* Write content */ wclear(header_win); wclear(file_win); mvwprintw(header_win, 0, (maxx - header.size())/2, header.c_str()); mvwprintw(file_win, 0, 0, " Anders_Bech_-_Store_patter_betyder_undskyld.mp3\n [##### ]"); /* Resize and refresh windows */ update_windows(&maxy, &maxx); /* Wait for keypress or timeout */ int key = wgetch(info_win); if (key != ERR) info_printf("Key pressed!\n"); } /* Finalize */ cleanup_and_exit(EXIT_SUCCESS); return 0; }
static void test_buffer(void) { char sbuf[16]; mget_buffer_t buf, *bufp; // testing buffer on stack, using initial stack memory // without resizing mget_buffer_init(&buf, sbuf, sizeof(sbuf)); mget_buffer_deinit(&buf); // testing buffer on stack, using initial stack memory // with resizing mget_buffer_init(&buf, sbuf, sizeof(sbuf)); _test_buffer(&buf, "Test 1"); mget_buffer_deinit(&buf); // testing buffer on stack, using initial heap memory // without resizing mget_buffer_init(&buf, NULL, 16); mget_buffer_deinit(&buf); // testing buffer on stack, using initial heap memory // with resizing mget_buffer_init(&buf, NULL, 16); _test_buffer(&buf, "Test 2"); mget_buffer_deinit(&buf); // testing buffer on heap, using initial stack memory // without resizing bufp = mget_buffer_init(NULL, sbuf, sizeof(sbuf)); mget_buffer_deinit(bufp); bufp = mget_buffer_init(NULL, sbuf, sizeof(sbuf)); mget_buffer_free(&bufp); // testing buffer on heap, using initial stack memory // with resizing bufp = mget_buffer_init(NULL, sbuf, sizeof(sbuf)); _test_buffer(bufp, "Test 3"); mget_buffer_deinit(bufp); bufp = mget_buffer_init(NULL, sbuf, sizeof(sbuf)); _test_buffer(bufp, "Test 4"); mget_buffer_free(&bufp); // testing buffer on heap, using initial heap memory // without resizing bufp = mget_buffer_alloc(16); mget_buffer_free(&bufp); // testing buffer on heap, using initial heap memory // with resizing bufp = mget_buffer_alloc(16); _test_buffer(bufp, "Test 5"); mget_buffer_free(&bufp); // check that appending works mget_buffer_init(&buf, sbuf, sizeof(sbuf)); mget_buffer_strcpy(&buf, "A"); mget_buffer_strcat(&buf, "B"); mget_buffer_memcat(&buf, "C", 1); mget_buffer_memset_append(&buf, 'D', 1); mget_buffer_printf_append2(&buf, "%s", "E"); if (!strcmp(buf.data, "ABCDE")) ok++; else { failed++; info_printf("test_buffer.append: got %s (expected %s)\n", buf.data, "ABCDE"); } mget_buffer_deinit(&buf); // test mget_buffer_trim() mget_buffer_init(&buf, sbuf, sizeof(sbuf)); for (int mid_ws = 0; mid_ws <= 2; mid_ws++) { char expected[16]; snprintf(expected, sizeof(expected), "x%.*sy", mid_ws, " "); for (int lead_ws = 0; lead_ws <= 2; lead_ws++) { for (int trail_ws = 0; trail_ws <= 2; trail_ws++) { mget_buffer_printf2(&buf, "%.*sx%.*sy%.*s", lead_ws, " ", mid_ws, " ", trail_ws, " "); mget_buffer_trim(&buf); if (!strcmp(buf.data, expected)) ok++; else { failed++; info_printf("test_buffer_trim: got '%s' (expected '%s') (%d, %d, %d)\n", buf.data, expected, lead_ws, mid_ws, trail_ws); } } } } mget_buffer_deinit(&buf); }
static void test_cookies(void) { static const struct test_data { const char *uri, *set_cookie, *name, *value, *domain, *path, *expires; unsigned int domain_dot : 1, // for compatibility with Netscape cookie format normalized : 1, persistent : 1, host_only : 1, secure_only : 1, // cookie should be used over secure connections only (TLS/HTTPS) http_only : 1; // just use the cookie via HTTP/HTTPS protocol int result, psl_result; } test_data[] = { { // allowed cookie "www.example.com", "ID=65=abcd; expires=Tuesday, 07-May-2013 07:48:53 GMT; path=/; domain=.example.com; HttpOnly", "ID", "65=abcd", "example.com", "/", "Tue, 07 May 2013 07:48:53 GMT", 1, 1, 1, 0, 0, 1, 0, 0 }, { // allowed cookie ANSI C's asctime format "www.example.com", "ID=65=abcd; expires=Tue May 07 07:48:53 2013; path=/; domain=.example.com", "ID", "65=abcd", "example.com", "/", "Tue, 07 May 2013 07:48:53 GMT", 1, 1, 1, 0, 0, 0, 0, 0 }, { // allowed cookie without path "www.example.com", "ID=65=abcd; expires=Tue, 07-May-2013 07:48:53 GMT; domain=.example.com", "ID", "65=abcd", "example.com", "/", "Tue, 07 May 2013 07:48:53 GMT", 1, 1, 1, 0, 0, 0, 0, 0 }, { // allowed cookie without domain "www.example.com", "ID=65=abcd; expires=Tue, 07-May-2013 07:48:53 GMT; path=/", "ID", "65=abcd", "www.example.com", "/", "Tue, 07 May 2013 07:48:53 GMT", 0, 1, 1, 1, 0, 0, 0, 0 }, { // allowed cookie without domain, path and expires "www.example.com", "ID=65=abcd", "ID", "65=abcd", "www.example.com", "/", "Tue, 07 May 2013 07:48:53 GMT", 0, 1, 0, 1, 0, 0, 0, 0 }, { // illegal cookie "www.example.com", "ID=65=abcd; expires=Tue, 07-May-2013 07:48:53 GMT; path=/; domain=.example.org", "ID", "65=abcd", "example.org", "/", "Tue, 07 May 2013 07:48:53 GMT", 1, 0, 1, 0, 0, 0, -1, 0 }, #ifdef WITH_LIBPSL { // supercookie, accepted by normalization (rule 'com') but not by mget_cookie_check_psl()) "www.example.com", "ID=65=abcd; expires=Mon, 29-Feb-2016 07:48:54 GMT; path=/; domain=.com; HttpOnly; Secure", "ID", "65=abcd", "com", "/", "Mon, 29 Feb 2016 07:48:54 GMT", 1, 0, 1, 0, 1, 1, 0, -1 }, { // supercookie, accepted by normalization (rule '*.ar') but not by mget_cookie_check_psl()) "www.sa.gov.au", "ID=65=abcd; expires=Tue, 29-Feb-2000 07:48:55 GMT; path=/; domain=.sa.gov.au", "ID", "65=abcd", "sa.gov.au", "/", "Tue, 29 Feb 2000 07:48:55 GMT", 1, 0, 1, 0, 0, 0, 0, -1 }, #endif { // exception rule '!educ.ar', accepted by normalization "www.educ.ar", "ID=65=abcd; path=/; domain=.educ.ar", "ID", "65=abcd", "educ.ar", "/", NULL, 1, 1, 0, 0, 0, 0, 0, 0 }, }; mget_cookie_t cookie; mget_cookie_db_t *cookies; mget_iri_t *iri; unsigned it; int result, result_psl; cookies = mget_cookie_db_init(NULL); mget_cookie_db_load_psl(cookies, DATADIR "/effective_tld_names.dat"); for (it = 0; it < countof(test_data); it++) { const struct test_data *t = &test_data[it]; char thedate[32], *header; iri = mget_iri_parse(t->uri, "utf-8"); mget_http_parse_setcookie(t->set_cookie, &cookie); if ((result = mget_cookie_normalize(iri, &cookie)) != t->result) { failed++; info_printf("Failed [%u]: normalize_cookie(%s) -> %d (expected %d)\n", it, t->set_cookie, result, t->result); mget_cookie_deinit(&cookie); goto next; } else { if ((result_psl = mget_cookie_check_psl(cookies, &cookie)) != t->psl_result) { failed++; info_printf("Failed [%u]: PSL check(%s) -> %d (expected %d)\n", it, t->set_cookie, result_psl, t->psl_result); } mget_cookie_deinit(&cookie); goto next; } if (cookie.expires) { mget_http_print_date(cookie.expires, thedate, sizeof(thedate)); if (strcmp(thedate, t->expires)) { failed++; info_printf("Failed [%u]: expires mismatch: '%s' != '%s' (time_t %lld)\n", it, thedate, t->expires, (long long)cookie.expires); mget_cookie_deinit(&cookie); goto next; } } if (strcmp(cookie.name, t->name) || strcmp(cookie.value, t->value) || strcmp(cookie.domain, t->domain) || strcmp(cookie.path, t->path) || cookie.domain_dot != t->domain_dot || cookie.normalized != t->normalized || cookie.persistent != t->persistent || cookie.host_only != t->host_only || cookie.secure_only != t->secure_only || cookie.http_only != t->http_only) { failed++; info_printf("Failed [%u]: cookie (%s) differs:\n", it, t->set_cookie); if (strcmp(cookie.name, t->name)) info_printf(" name %s (expected %s)\n", cookie.name, t->name); if (strcmp(cookie.value, t->value)) info_printf(" value %s (expected %s)\n", cookie.value, t->value); if (strcmp(cookie.domain, t->domain)) info_printf(" domain %s (expected %s)\n", cookie.domain, t->domain); if (strcmp(cookie.path, t->path)) info_printf(" path %s (expected %s)\n", cookie.path, t->path); if (cookie.domain_dot != t->domain_dot) info_printf(" domain_dot %d (expected %d)\n", cookie.domain_dot, t->domain_dot); if (cookie.normalized != t->normalized) info_printf(" normalized %d (expected %d)\n", cookie.normalized, t->normalized); if (cookie.persistent != t->persistent) info_printf(" persistent %d (expected %d)\n", cookie.persistent, t->persistent); if (cookie.host_only != t->host_only) info_printf(" host_only %d (expected %d)\n", cookie.host_only, t->host_only); if (cookie.secure_only != t->secure_only) info_printf(" secure_only %d (expected %d)\n", cookie.secure_only, t->secure_only); if (cookie.http_only != t->http_only) info_printf(" http_only %d (expected %d)\n", cookie.http_only, t->http_only); mget_cookie_deinit(&cookie); goto next; } mget_cookie_store_cookie(cookies, &cookie); info_printf("%s\n", header = mget_cookie_create_request_header(cookies, iri)); xfree(header); ok++; next: mget_iri_free(&iri); } mget_cookie_db_free(&cookies); }