int cgiMain() { static char title[256] = ""; static char subtitle[256] = ""; char sorting[16] = "desc"; time_t now = time(NULL); time_t start = time(NULL); time_t expiration = time(NULL); double available_secs = 0; double remaining_secs = 0; struct dirent **certstore_files = NULL; int pagenumber = 1; int certcounter = 0; int tempcounter = 0; int pagecounter = 0; int dispcounter = 0; int dispmaxlines = 0; int certvalidity = 0; div_t disp_calc; div_t oddline_calc; double percent = 0; cert = X509_new(); certsubject = X509_NAME_new(); char **form_data = NULL; /* string array for query data */ /* get the current time */ now = time(NULL); /* ------------------------------------------------------------------------- * * If we are called without arguments, we display the cert search criteria * * ------------------------------------------------------------------------- */ if (cgiFormEntries(&form_data) != cgiFormSuccess) int_error("Error: Could not retrieve CGI form data."); if(form_data[0] == NULL) { start_tm = *gmtime(&now); snprintf(title, sizeof(title), "Search existing Certificates"); pagehead(title); fprintf(cgiOut, "<form action=\"certsearch.cgi\" method=\"get\">"); fprintf(cgiOut, "<table>"); /* Search for Subject String */ fprintf(cgiOut, "<tr><th colspan=\"5\">Search by Name</th></tr>\n"); fprintf(cgiOut, "<tr>\n"); fprintf(cgiOut, "<th class=\"cnt\" rowspan=\"2\">\n"); fprintf(cgiOut, "<input type=\"radio\" value=\"dn\" name=\"search\" />"); fprintf(cgiOut, "</th>\n"); fprintf(cgiOut, "<td class=\"type\">\n"); fprintf(cgiOut, "Distinguished Name Field:"); fprintf(cgiOut, "</td>\n"); fprintf(cgiOut, "<td class=\"center\">\n"); fprintf(cgiOut, "<select name=\"field\">"); fprintf(cgiOut, "<option value=\"countryName\">Country</option>"); fprintf(cgiOut, "<option value=\"stateOrProvinceName\">State</option>"); fprintf(cgiOut, "<option value=\"localityName\">Location</option>"); fprintf(cgiOut, "<option value=\"organizationName\">Organisation</option>"); fprintf(cgiOut, "<option value=\"organizationalUnitName\">Department</option>"); fprintf(cgiOut, "<option value=\"emailAddress\">E-Mail Addr</option>"); fprintf(cgiOut, "<option selected=\"selected\" value=\"commonName\">Common Name</option>"); fprintf(cgiOut, "<option value=\"surname\">Surname</option>"); fprintf(cgiOut, "<option value=\"givenName\">Given Name</option>"); fprintf(cgiOut, "</select>"); fprintf(cgiOut, "</td>\n"); fprintf(cgiOut, "<td class=\"type\">\n"); fprintf(cgiOut, "Search String<br />[20 chars max]:"); fprintf(cgiOut, "</td>\n"); fprintf(cgiOut, "<td class=\"center\">\n"); fprintf(cgiOut, "<input type=\"text\" size=\"15\" name=\"dnvalue\" value=\"changeme.com\" />"); fprintf(cgiOut, "</td>"); fprintf(cgiOut, "</tr>\n"); fprintf(cgiOut, "<tr>\n"); fprintf(cgiOut, "<td class=\"desc\" colspan=\"4\">\n"); fprintf(cgiOut, "Search for certificates that have the given string in the selected DN field. "); fprintf(cgiOut, "The search is case sensitive, so results for country=us can be different from country=US and country=Us."); fprintf(cgiOut, "</td>\n"); fprintf(cgiOut, "</tr>\n"); /* Search for Expiration Date */ fprintf(cgiOut, "<tr><th colspan=\"5\">Search by Expiration Date</th></tr>\n"); fprintf(cgiOut, "<tr>\n"); fprintf(cgiOut, "<th class=\"cnt\" rowspan=\"2\">\n"); fprintf(cgiOut, "<input type=\"radio\" value=\"exp\" name=\"search\" checked=\"checked\" />"); fprintf(cgiOut, "</th>\n"); fprintf(cgiOut, "<td class=\"type\">\n"); fprintf(cgiOut, "Expiration Date is<br />between Start Date:"); fprintf(cgiOut, "</td>\n"); fprintf(cgiOut, "<td class=\"center\">\n"); strftime(membio_buf, sizeof(membio_buf), "%d.%m.%Y", &start_tm); fprintf(cgiOut, "<input type=\"text\" size=\"9\" name=\"exp_startdate\" value=\"%s\" /> ", membio_buf); strftime(membio_buf, sizeof(membio_buf), "%H:%M", &start_tm); fprintf(cgiOut, "<input type=\"text\" size=\"3\" name=\"exp_starttime\" value=\"%s\" />", membio_buf); fprintf(cgiOut, "</td>"); fprintf(cgiOut, "<td class=\"type\">\n"); fprintf(cgiOut, "and End Date<br />[default 90 days]:"); fprintf(cgiOut, "</td>\n"); fprintf(cgiOut, "<td class=\"center\">\n"); /* set second time 3 months (90 days) into the future: 86400s/d*90d=7776000s */ expiration = now + 7776000; expiration_tm = *gmtime(&expiration); strftime(membio_buf, sizeof(membio_buf), "%d.%m.%Y", &expiration_tm); fprintf(cgiOut, "<input type=\"text\" size=\"9\" name=\"exp_enddate\" value=\"%s\" /> ", membio_buf); strftime(membio_buf, sizeof(membio_buf), "%H:%M", &expiration_tm); fprintf(cgiOut, "<input type=\"text\" size=\"3\" name=\"exp_endtime\" value=\"%s\" />", membio_buf); fprintf(cgiOut, "</td>"); fprintf(cgiOut, "</tr>\n"); fprintf(cgiOut, "<tr>\n"); fprintf(cgiOut, "<td class=\"desc\" colspan=\"4\">\n"); fprintf(cgiOut, "Search for certificates that expire(d) between the selected start and end date. "); fprintf(cgiOut, "By default, the search is pre-set to find certificates that expire in the next 3 months."); fprintf(cgiOut, "</td>\n"); fprintf(cgiOut, "</tr>\n"); /* Search for Enabled Date */ fprintf(cgiOut, "<tr><th colspan=\"5\">Search by Creation Date</th></tr>\n"); fprintf(cgiOut, "<tr>\n"); fprintf(cgiOut, "<th class=\"cnt\" rowspan=\"2\">\n"); fprintf(cgiOut, "<input type=\"radio\" value=\"ena\" name=\"search\" />"); fprintf(cgiOut, "</th>\n"); fprintf(cgiOut, "<td class=\"type\">\n"); fprintf(cgiOut, "Enabled Date is<br />between Start Date:"); fprintf(cgiOut, "</td>\n"); fprintf(cgiOut, "<td class=\"center\">\n"); /* set second time 3 months (90 days) into the past: 86400s/d*90d=7776000s */ expiration = now - 7776000; expiration_tm = *gmtime(&expiration); strftime(membio_buf, sizeof(membio_buf), "%d.%m.%Y", &expiration_tm); fprintf(cgiOut, "<input type=\"text\" size=\"9\" name=\"ena_startdate\" value=\"%s\" /> ", membio_buf); strftime(membio_buf, sizeof(membio_buf), "%H:%M", &expiration_tm); fprintf(cgiOut, "<input type=\"text\" size=\"3\" name=\"ena_starttime\" value=\"%s\" />", membio_buf); fprintf(cgiOut, "</td>"); fprintf(cgiOut, "<td class=\"type\">\n"); fprintf(cgiOut, "and End Date<br />[default now]:"); fprintf(cgiOut, "</td>\n"); fprintf(cgiOut, "<td class=\"center\">\n"); strftime(membio_buf, sizeof(membio_buf), "%d.%m.%Y", &start_tm); fprintf(cgiOut, "<input type=\"text\" size=\"9\" name=\"ena_enddate\" value=\"%s\" /> ", membio_buf); strftime(membio_buf, sizeof(membio_buf), "%H:%M", &start_tm); fprintf(cgiOut, "<input type=\"text\" size=\"3\" name=\"ena_endtime\" value=\"%s\" />", membio_buf); fprintf(cgiOut, "</td>"); fprintf(cgiOut, "</tr>\n"); fprintf(cgiOut, "<tr>\n"); fprintf(cgiOut, "<td class=\"desc\" colspan=\"4\">\n"); fprintf(cgiOut, "Search for certificates that become valid between the selected start and end date. "); fprintf(cgiOut, "By default, the search is pre-set to show certificates created in the past 3 months."); fprintf(cgiOut, "</td>\n"); fprintf(cgiOut, "</tr>\n"); /* Search for Revocation Date */ fprintf(cgiOut, "<tr><th colspan=\"5\">Search by Revocation Date</th></tr>\n"); fprintf(cgiOut, "<tr>\n"); fprintf(cgiOut, "<th class=\"cnt\" rowspan=\"2\">\n"); fprintf(cgiOut, "<input type=\"radio\" value=\"rev\" name=\"search\" />"); fprintf(cgiOut, "</th>\n"); fprintf(cgiOut, "<td class=\"type\">\n"); fprintf(cgiOut, "Revocation Date is<br />between Start Date:"); fprintf(cgiOut, "</td>\n"); fprintf(cgiOut, "<td class=\"center\">\n"); /* set second time 3 months (90 days) into the past: 86400s/d*90d=7776000s */ expiration = now - 7776000; expiration_tm = *gmtime(&expiration); strftime(membio_buf, sizeof(membio_buf), "%d.%m.%Y", &expiration_tm); fprintf(cgiOut, "<input type=\"text\" size=\"9\" name=\"rev_startdate\" value=\"%s\" /> ", membio_buf); strftime(membio_buf, sizeof(membio_buf), "%H:%M", &expiration_tm); fprintf(cgiOut, "<input type=\"text\" size=\"3\" name=\"rev_starttime\" value=\"%s\"/>", membio_buf); fprintf(cgiOut, "</td>"); fprintf(cgiOut, "<td class=\"type\">\n"); fprintf(cgiOut, "and End Date<br />[now]:"); fprintf(cgiOut, "</td>\n"); fprintf(cgiOut, "<td class=\"center\">\n"); strftime(membio_buf, sizeof(membio_buf), "%d.%m.%Y", &start_tm); fprintf(cgiOut, "<input type=\"text\" size=\"9\" name=\"rev_enddate\" value=\"%s\" /> ", membio_buf); strftime(membio_buf, sizeof(membio_buf), "%H:%M", &start_tm); fprintf(cgiOut, "<input type=\"text\" size=\"3\" name=\"rev_endtime\" value=\"%s\" />", membio_buf); fprintf(cgiOut, "</td>"); fprintf(cgiOut, "</tr>\n"); fprintf(cgiOut, "<tr>\n"); fprintf(cgiOut, "<td class=\"desc\" colspan=\"4\">\n"); fprintf(cgiOut, "Search for certificates that have been revoked between the selected start and end date. "); fprintf(cgiOut, " By default, the search is pre-set to show certificates revoked in the past 3 months."); fprintf(cgiOut, "</td>\n"); fprintf(cgiOut, "</tr>\n"); /* Search for Serial Number */ fprintf(cgiOut, "<tr><th colspan=\"5\">Search by Serial Number</th></tr>\n"); fprintf(cgiOut, "<tr>\n"); fprintf(cgiOut, "<th class=\"cnt\" rowspan=\"2\">\n"); fprintf(cgiOut, "<input type=\"radio\" value=\"ser\" name=\"search\" />"); fprintf(cgiOut, "</th>\n"); fprintf(cgiOut, "<td class=\"type\">\n"); fprintf(cgiOut, "Serial Number is<br />between Start Serial:"); fprintf(cgiOut, "</td>\n"); fprintf(cgiOut, "<td class=\"center\">\n"); fprintf(cgiOut, "<input type=\"text\" size=\"14\" name=\"startserial\" "); fprintf(cgiOut, "value=\"%s\" style=\"text-align:right;\" />", startserstr); fprintf(cgiOut, "</td>"); fprintf(cgiOut, "<td class=\"type\">\n"); fprintf(cgiOut, "and End Serial<br />[max 10e11]:"); fprintf(cgiOut, "</td>\n"); fprintf(cgiOut, "<td class=\"center\">\n"); fprintf(cgiOut, "<input type=\"text\" size=\"14\" name=\"endserial\" "); fprintf(cgiOut, "value=\"%s\" style=\"text-align:right;\" />", endserstr); fprintf(cgiOut, "</td>"); fprintf(cgiOut, "</tr>\n"); fprintf(cgiOut, "<tr>\n"); fprintf(cgiOut, "<td class=\"desc\" colspan=\"4\">\n"); fprintf(cgiOut, "Search for certificates whose serial number is between the given "); fprintf(cgiOut, "start and end serial number in decimal format. To find a particular certificate, set start and end serial to be equal."); fprintf(cgiOut, "</td>\n"); fprintf(cgiOut, "</tr>\n"); fprintf(cgiOut, "<tr>\n"); fprintf(cgiOut, "<th colspan=\"5\">"); fprintf(cgiOut, "<input type=\"submit\" value=\"Search Certificates\" />"); fprintf(cgiOut, "</th>"); fprintf(cgiOut, "</tr>\n"); fprintf(cgiOut, "</table>\n"); fprintf(cgiOut, "</form>\n"); pagefoot(); } else { /* ------------------------------------------------------------------- * * check if we got the CGI form data * * --------------------------------------------------------------------*/ if ( cgiFormString("search", search, sizeof(search)) != cgiFormSuccess ) int_error("Error retrieving CGI form search type."); else { if (strcmp(search, "dn") == 0) { if ( cgiFormString("field", field, sizeof(field)) != cgiFormSuccess ) int_error("Error retrieving CGI form DN search field information."); if ( cgiFormString("dnvalue", dnvalue, sizeof(dnvalue)) != cgiFormSuccess ) int_error("Error retrieving CGI form DN search dnvalue information."); snprintf(title, sizeof(title), "Search Certs by Subject"); snprintf(subtitle, sizeof(subtitle), "Certificates with DN %s=%s", field, dnvalue); } else if (strcmp(search, "exp") == 0) { if ( cgiFormString("exp_startdate", exp_startdate, sizeof(exp_startdate)) != cgiFormSuccess ) int_error("Error retrieving CGI form expiration start date."); if ( cgiFormString("exp_starttime", exp_starttime, sizeof(exp_starttime)) != cgiFormSuccess ) int_error("Error retrieving CGI form expiration start time."); if ( cgiFormString("exp_enddate", exp_enddate, sizeof(exp_enddate)) != cgiFormSuccess ) int_error("Error retrieving CGI form expiration end date."); if ( cgiFormString("exp_endtime", exp_endtime, sizeof(exp_endtime)) != cgiFormSuccess ) int_error("Error retrieving CGI form expiration end time."); strncat(exp_startstr, exp_startdate, sizeof(exp_startstr)-1); strncat(exp_startstr, " ", 1); /* add a space between date and time */ strncat(exp_startstr, exp_starttime, sizeof(exp_startstr)-strlen(exp_startstr)-1); strncat(exp_endstr, exp_enddate, sizeof(exp_endstr)-1); strncat(exp_endstr, " ", 1); /* add a space between date and time */ strncat(exp_endstr, exp_endtime, sizeof(exp_endstr)-strlen(exp_endstr)-1); snprintf(title, sizeof(title), "Search Certs by Expiration"); snprintf(subtitle, sizeof(subtitle), "Certificates with expiration between %s and %s", exp_startstr, exp_endstr); } else if (strcmp(search, "ena") == 0) { if ( cgiFormString("ena_startdate", ena_startdate, sizeof(ena_startdate)) != cgiFormSuccess ) int_error("Error retrieving CGI form enable start date."); if ( cgiFormString("ena_starttime", ena_starttime, sizeof(ena_starttime)) != cgiFormSuccess ) int_error("Error retrieving CGI form enable start time."); if ( cgiFormString("ena_enddate", ena_enddate, sizeof(ena_enddate)) != cgiFormSuccess ) int_error("Error retrieving CGI form enable end date."); if ( cgiFormString("ena_endtime", ena_endtime, sizeof(ena_endtime)) != cgiFormSuccess ) int_error("Error retrieving CGI form enable end time."); strncat(ena_startstr, ena_startdate, sizeof(ena_startstr)-1); strncat(ena_startstr, " ", 1); /* add a space between date and time */ strncat(ena_startstr, ena_starttime, sizeof(ena_startstr)-strlen(ena_startstr)-1); strncat(ena_endstr, ena_enddate, sizeof(ena_endstr)-1); strncat(ena_endstr, " ", 1); /* add a space between date and time */ strncat(ena_endstr, ena_endtime, sizeof(ena_endstr)-strlen(ena_endstr)-1); snprintf(title, sizeof(title), "Search Certs by Start Date"); snprintf(subtitle, sizeof(subtitle), "Certificates with start date between %s and %s", ena_startstr, ena_endstr); } else if (strcmp(search, "rev") == 0) { if ( cgiFormString("rev_startdate", rev_startdate, sizeof(rev_startdate)) != cgiFormSuccess ) int_error("Error retrieving CGI form enable start date."); if ( cgiFormString("rev_starttime", rev_starttime, sizeof(rev_starttime)) != cgiFormSuccess ) int_error("Error retrieving CGI form enable start time."); if ( cgiFormString("rev_enddate", rev_enddate, sizeof(rev_enddate)) != cgiFormSuccess ) int_error("Error retrieving CGI form enable end date."); if ( cgiFormString("rev_endtime", rev_endtime, sizeof(rev_endtime)) != cgiFormSuccess ) int_error("Error retrieving CGI form enable end time."); strncat(rev_startstr, rev_startdate, sizeof(rev_startstr)-1); strncat(rev_startstr, " ", 1); /* add a space between date and time */ strncat(rev_startstr, rev_starttime, sizeof(rev_startstr)-strlen(rev_startstr)-1); strncat(rev_endstr, rev_enddate, sizeof(rev_endstr)-1); strncat(rev_endstr, " ", 1); /* add a space between date and time */ strncat(rev_endstr, rev_endtime, sizeof(rev_endstr)-strlen(rev_endstr)-1); snprintf(title, sizeof(title), "Search Revoked Certificates"); snprintf(subtitle, sizeof(subtitle), "Certificates revoked between %s and %s", rev_startstr, rev_endstr); } else if (strcmp(search, "ser") == 0) { if ( cgiFormString("startserial", startserstr, sizeof(startserstr)) != cgiFormSuccess ) int_error("Error retrieving CGI form start serial value."); if ( cgiFormString("endserial", endserstr, sizeof(endserstr)) != cgiFormSuccess ) int_error("Error retrieving CGI form end serial value."); snprintf(title, sizeof(title), "Search Certs by Serial Number"); snprintf(subtitle, sizeof(subtitle), "Certificates with serial number between %s and %s", startserstr, endserstr); } else int_error("Error CGI form retrieving a valid search type."); } /* -------------------------------------------------------------------------- * * We got CGI arguments, first we get a list of .pem files from the cert dir * * ---------------------------------------------------------------------------*/ certcounter = scandir(CACERTSTORE, &certstore_files, file_select, hexsort); // It can happen that our search does not return any certs. This is not an error. //if(certcounter<=0) int_error("Error: No certificate files found."); /* -------------------------------------------------------------------------- * * calculate how many pages we get with MAXCERTDISPLAY * * ---------------------------------------------------------------------------*/ if(certcounter<=MAXCERTDISPLAY) pagecounter = 1; else { disp_calc = div(certcounter, MAXCERTDISPLAY); /* if the count of certs divided by MAXCERTDISPLAY has no remainder */ if(disp_calc.rem == 0) pagecounter = disp_calc.quot; /* with a remainder, we must prepare an extra page for the rest */ else pagecounter = disp_calc.quot +1; } /* -------------------------------------------------------------------------- * * Check if we have been subsequently called with a pagenumber & sort request * * ---------------------------------------------------------------------------*/ if(cgiFormInteger("page", &pagenumber, 1) == cgiFormSuccess) if(pagenumber > pagecounter || pagenumber <=0) int_error("Error: Page does not exist."); if(cgiFormString("sort", sorting, sizeof(sorting)) != cgiFormSuccess) strncpy(sorting, "desc", sizeof(sorting)); /* -------------------------------------------------------------------------- * * now we know how many certs we have in total and we can build the page(s). * * For every MAXCERTDISPLAY certs we start a new page and cycle through by * * calling ourself with the requested certs in range. * * ---------------------------------------------------------------------------*/ if(strcmp(sorting, "asc") == 0) { if(certcounter <= MAXCERTDISPLAY) { dispmaxlines = certcounter; tempcounter = 0; } else if(pagenumber == pagecounter && ( pagecounter * MAXCERTDISPLAY) - certcounter != 0) { tempcounter = (pagecounter * MAXCERTDISPLAY) - MAXCERTDISPLAY; dispmaxlines = certcounter - ((pagecounter-1) * MAXCERTDISPLAY); } else { tempcounter = (pagenumber * MAXCERTDISPLAY) - MAXCERTDISPLAY; dispmaxlines = MAXCERTDISPLAY; } } if(strcmp(sorting, "desc") == 0) { if(certcounter <= MAXCERTDISPLAY) { dispmaxlines = certcounter; tempcounter = certcounter; } else if(pagenumber == pagecounter && ( pagecounter * MAXCERTDISPLAY) - certcounter != 0) { tempcounter = certcounter - ((pagecounter-1) * MAXCERTDISPLAY); dispmaxlines = certcounter - ((pagecounter-1) * MAXCERTDISPLAY); } else { tempcounter = certcounter - (pagenumber*MAXCERTDISPLAY) + MAXCERTDISPLAY; dispmaxlines = MAXCERTDISPLAY; } } /* -------------------------------------------------------------------------- * * start the html output * * ---------------------------------------------------------------------------*/ pagehead(title); //debugging only: //printf("Number of certs: %d\n", certcounter); //printf("Num tempcounter: %d\n", tempcounter); //printf("Number of pages: %d\n", pagecounter); //printf("Div Quotient: %d\n", disp_calc.quot); //printf("Div Remainder: %d\n", disp_calc.rem); //fprintf(cgiOut, "</BODY></HTML>\n"); //exit(0); /* -------------------------------------------------------------------------- * * start the form output * * ---------------------------------------------------------------------------*/ fprintf(cgiOut, "<h3>%s</h3>\n", subtitle); fprintf(cgiOut, "<p></p>\n"); fprintf(cgiOut, "<table>\n"); fprintf(cgiOut, "<tr>\n"); fprintf(cgiOut, "<th width=\"20\">"); fprintf(cgiOut, "#"); fprintf(cgiOut, "</th>\n"); fprintf(cgiOut, "<th width=\"495\">"); fprintf(cgiOut, "Certificate Subject Information"); fprintf(cgiOut, "</th>\n"); fprintf(cgiOut, "<th width=\"60\" colspan=\"2\">"); fprintf(cgiOut, "Expires"); fprintf(cgiOut, "</th>\n"); fprintf(cgiOut, "<th width=\"65\">"); fprintf(cgiOut, "Action"); fprintf(cgiOut, "</th>\n"); fprintf(cgiOut, "</tr>\n"); /* if our search did not return any certs, we display a note instead */ if(certcounter<=0) { fprintf(cgiOut, "<tr>\n"); fprintf(cgiOut, "<td class=\"even\" colspan=\"5\">"); fprintf(cgiOut, "Could not find any certificates for the given search criteria."); fprintf(cgiOut, "</td>\n"); fprintf(cgiOut, "</tr>\n"); } for(dispcounter=0; dispcounter < dispmaxlines; dispcounter++) { /* zero certificate values and flags */ certvalidity = 0; percent = 0; available_secs = 0; remaining_secs = 0; cert = X509_new(); certsubject = X509_NAME_new(); if(strcmp(sorting, "desc") == 0) tempcounter--; snprintf(certfilestr, sizeof(certfilestr), "%s/%s", CACERTSTORE, certstore_files[tempcounter]->d_name); fprintf(cgiOut, "<tr>\n"); fprintf(cgiOut, "<th rowspan=\"2\">"); fprintf(cgiOut, "%d", tempcounter+1); fprintf(cgiOut, "</th>\n"); oddline_calc = div(tempcounter+1, 2); if(oddline_calc.rem) fprintf(cgiOut, "<td rowspan=\"2\" class=\"odd\">"); else fprintf(cgiOut, "<td rowspan=\"2\" class=\"even\">"); if ( (certfile = fopen(certfilestr, "r")) != NULL) { PEM_read_X509(certfile, &cert, NULL, NULL); /* ---------------------------------------------------------- * * Display the subject data. Use the UTF-8 flag to show * * Japanese Kanji. This also needs the separator flag to work * * ---------------------------------------------------------- */ certsubject = X509_get_subject_name(cert); X509_NAME_print_ex_fp(cgiOut, certsubject, 0, ASN1_STRFLGS_UTF8_CONVERT|XN_FLAG_SEP_CPLUS_SPC); /* store certificate start date for later eval */ start_date = X509_get_notBefore(cert); /* store certificate expiration date for later eval */ expiration_date = X509_get_notAfter(cert); /* check the start and end dates in the cert */ if (X509_cmp_current_time (X509_get_notBefore (cert)) >= 0) /* flag the certificate as not valid yet */ certvalidity = 0; else if (X509_cmp_current_time (X509_get_notAfter (cert)) <= 0) /* flag the certificate as expired */ certvalidity = 0; else /* flag the certificate is still valid */ certvalidity = 1; fclose(certfile); } else fprintf(cgiOut, "Error: Can't open certificate file %s for reading.", certfilestr); fprintf(cgiOut, "</td>\n"); if(certvalidity == 0) { /* expiration bar display column */ fprintf(cgiOut, "<th rowspan=\"2\">\n"); fprintf(cgiOut, "<table class=\"led\">\n"); fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); fprintf(cgiOut, "</table>\n"); fprintf(cgiOut, "</th>\n"); /* remaining days before expiration column */ fprintf(cgiOut, "<th class=\"exnok\" rowspan=\"2\">"); fprintf(cgiOut, "Inval.<br />/Expd"); fprintf(cgiOut, "</th>\n"); } if(certvalidity == 1) { /* ------ START get the certificate lifetime in seconds ------ */ /* copy the start date into a string */ membio = BIO_new(BIO_s_mem()); ASN1_TIME_print(membio, start_date); BIO_gets(membio, membio_buf, sizeof(membio_buf)); BIO_free(membio); /* parse the start date string into a time struct */ memset (&start_tm, '\0', sizeof(start_tm)); strptime(membio_buf, "%h %d %T %Y %z", &start_tm); start = mktime(&start_tm); /* ------ START get the certificate remaining time in seconds ------ */ /* copy the expiration date into a string */ membio = BIO_new(BIO_s_mem()); ASN1_TIME_print(membio, expiration_date); BIO_gets(membio, membio_buf, sizeof(membio_buf)); BIO_free(membio); /* parse the expiration date string into a time struct */ memset (&expiration_tm, '\0', sizeof(expiration_tm)); strptime(membio_buf, "%h %d %T %Y %z", &expiration_tm); /* get the current time */ expiration = mktime(&expiration_tm); /* get the time difference between expiration time and current time */ remaining_secs = difftime(expiration, now); /* ------ END get the certificate remaining time in seconds ------ */ /* get the time difference between start and expiration time */ available_secs = difftime(expiration, start); /* ------ END get the certificate lifetime in seconds ------ */ /* ------ START calculate percentage of lifetime left ------ */ /* remaining_secs *100 */ /* ------------------- = X, rounded down with floor() */ /* available_secs */ percent = floor((remaining_secs*100)/available_secs); /* ------ END calculate percentage of lifetime left ------ */ /* expiration bar display column */ fprintf(cgiOut, "<th rowspan=\"2\">"); fprintf(cgiOut, "<table class=\"led\">\n"); if (percent >= 90) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#00FF00></td></tr>\n"); else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); if (percent >= 80) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#00FF33></td></tr>\n"); else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); if (percent >= 70) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#99FF33></td></tr>\n"); else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); if (percent >= 60) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#FFFF00></td></tr>\n"); else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); if (percent >= 50) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#FFCC00></td></tr>\n"); else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); if (percent >= 40) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#FF9900></td></tr>\n"); else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); if (percent >= 30) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#FF6600></td></tr>\n"); else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); if (percent >= 20) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#FF3300></td></tr>\n"); else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); if (percent >= 10) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#FF0000></td></tr>\n"); else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n"); fprintf(cgiOut, "</table>\n"); fprintf(cgiOut, "</th>"); /* remaining days before expiration column */ //fprintf(cgiOut, membio_buf); if (percent < 10) fprintf(cgiOut, "<th class=\"exnok\" rowspan=\"2\">\n"); else fprintf(cgiOut, "<th class=\"exok\" rowspan=\"2\">\n"); if(floor(remaining_secs/63072000) > 0) fprintf(cgiOut, "%.f<br />years", remaining_secs/31536000); else if(floor(remaining_secs/86400) > 0 ) fprintf(cgiOut, "%.f<br />days", remaining_secs/86400); else if(floor(remaining_secs/3600) > 0 ) fprintf(cgiOut, "%.f<br />hours", remaining_secs/3600); else if(floor(remaining_secs/60) > 0 ) fprintf(cgiOut, "%.f<br />mins", remaining_secs/60); else fprintf(cgiOut, "%.f<br />secs", remaining_secs); fprintf(cgiOut, "</th>\n"); } /* action column */ fprintf(cgiOut, "<th>"); fprintf(cgiOut, "<form action=\"getcert.cgi\" method=\"post\">\n"); fprintf(cgiOut, "<input type=\"hidden\" name=\"cfilename\" "); fprintf(cgiOut, "value=\"%s\" />\n", certstore_files[tempcounter]->d_name); fprintf(cgiOut, "<input type=\"hidden\" name=\"format\" value=\"pem\" />\n"); fprintf(cgiOut, "<input class=\"getcert\" type=\"submit\" value=\"Detail\" />\n"); fprintf(cgiOut, "</form>\n"); fprintf(cgiOut, "</th>\n"); fprintf(cgiOut, "</tr>\n"); fprintf(cgiOut, "<tr>\n"); fprintf(cgiOut, "<th>"); fprintf(cgiOut, "<form action=\"getcert.cgi\" method=\"post\">\n"); fprintf(cgiOut, "<input type=\"hidden\" name=\"cfilename\" "); fprintf(cgiOut, "value=\"%s\" />\n", certstore_files[tempcounter]->d_name); fprintf(cgiOut, "<input type=\"hidden\" name=\"format\" value=\"text\" />\n"); fprintf(cgiOut, "<input class=\"getcert\" type=\"submit\" value=\"Renew\" />\n"); fprintf(cgiOut, "</form>"); fprintf(cgiOut, "</th>\n"); fprintf(cgiOut, "</tr>\n"); if(strcmp(sorting, "asc") == 0) tempcounter++; } fprintf(cgiOut, "<tr>\n"); fprintf(cgiOut, "<th colspan=\"5\">"); fprintf(cgiOut, "Total # of certs: %d | ", certcounter); fprintf(cgiOut, "Page %d of %d", pagenumber, pagecounter); fprintf(cgiOut, "</th>"); fprintf(cgiOut, "</tr>"); fprintf(cgiOut, "</table>\n"); fprintf(cgiOut, "<p></p>\n"); fprintf(cgiOut, "<table>\n"); fprintf(cgiOut, "<tr>\n"); fprintf(cgiOut, "<th>"); fprintf(cgiOut, "<form action=\"certsearch.cgi\" method=\"post\">"); fprintf(cgiOut, "<input type=\"hidden\" name=\"sort\" "); fprintf(cgiOut, "value=\"desc\" />\n"); resubmit(); fprintf(cgiOut, "<input type=\"submit\" name=\"sort\""); fprintf(cgiOut, " value=\"Latest Certs first\" />"); fprintf(cgiOut, "</form>"); fprintf(cgiOut, "</th>\n"); fprintf(cgiOut, "<th>"); fprintf(cgiOut, "<form action=\"certsearch.cgi\" method=\"post\">"); fprintf(cgiOut, "<input type=\"hidden\" name=\"sort\" "); fprintf(cgiOut, "value=\"asc\">\n"); resubmit(); fprintf(cgiOut, "<input type=\"submit\" name=\"sort\""); fprintf(cgiOut, " value=\"Oldest Certs first\">"); fprintf(cgiOut, "</form>"); fprintf(cgiOut, "</th>\n"); // filler 1 fprintf(cgiOut, "<th width=\"15\">"); fprintf(cgiOut, " "); fprintf(cgiOut, "</th>\n"); // goto page 1 fprintf(cgiOut, "<th width=\"5\">"); fprintf(cgiOut, "<form action=\"certsearch.cgi\" method=\"post\">"); resubmit(); fprintf(cgiOut, "<input type=\"submit\" value=\"<<\" />"); fprintf(cgiOut, "</form>"); fprintf(cgiOut, "</th>\n"); // goto page before fprintf(cgiOut, "<th width=\"5\">"); fprintf(cgiOut, "<form action=\"certsearch.cgi\" method=\"post\">"); fprintf(cgiOut, "<input type=\"hidden\" name=\"certcounter\" "); fprintf(cgiOut, "value=\""); fprintf(cgiOut, "%d", certcounter); fprintf(cgiOut, "\" />\n"); fprintf(cgiOut, "<input type=\"hidden\" name=\"pagecounter\" "); fprintf(cgiOut, "value=\""); fprintf(cgiOut, "%d", pagecounter); fprintf(cgiOut, "\" />\n"); fprintf(cgiOut, "<input type=\"hidden\" name=\"page\" "); fprintf(cgiOut, "value=\""); tempcounter = 0; if(pagenumber > 1) tempcounter = pagenumber - 1; else tempcounter = 1; fprintf(cgiOut, "%d", tempcounter); fprintf(cgiOut, "\" />\n"); resubmit(); fprintf(cgiOut, "<input type=\"submit\" value=\"< 1\">"); fprintf(cgiOut, "</form>"); fprintf(cgiOut, "</th>\n"); // goto page after fprintf(cgiOut, "<th width=\"5\">"); fprintf(cgiOut, "<form action=\"certsearch.cgi\" method=\"post\">"); fprintf(cgiOut, "<input type=\"hidden\" name=\"certcounter\" "); fprintf(cgiOut, "value=\""); fprintf(cgiOut, "%d", certcounter); fprintf(cgiOut, "\" />\n"); fprintf(cgiOut, "<input type=\"hidden\" name=\"pagecounter\" "); fprintf(cgiOut, "value=\""); fprintf(cgiOut, "%d", pagecounter); fprintf(cgiOut, "\" />\n"); fprintf(cgiOut, "<input type=\"hidden\" name=\"page\" "); fprintf(cgiOut, "value=\""); tempcounter = 0; if(pagecounter > pagenumber) tempcounter = pagenumber + 1; else tempcounter = pagecounter; fprintf(cgiOut, "%d", tempcounter); fprintf(cgiOut, "\" />\n"); resubmit(); fprintf(cgiOut, "<input type=\"submit\" value=\"1 >\" />"); fprintf(cgiOut, "</form>"); fprintf(cgiOut, "</th>\n"); // goto last page fprintf(cgiOut, "<th width=\"5\">"); fprintf(cgiOut, "<form action=\"certsearch.cgi\" method=\"post\">"); fprintf(cgiOut, "<input type=\"hidden\" name=\"certcounter\" "); fprintf(cgiOut, "value=\""); fprintf(cgiOut, "%d", certcounter); fprintf(cgiOut, "\" />\n"); fprintf(cgiOut, "<input type=\"hidden\" name=\"pagecounter\" "); fprintf(cgiOut, "value=\""); fprintf(cgiOut, "%d", pagecounter); fprintf(cgiOut, "\" />\n"); fprintf(cgiOut, "<input type=\"hidden\" name=\"page\" "); fprintf(cgiOut, "value=\""); fprintf(cgiOut, "%d", pagecounter); fprintf(cgiOut, "\" />\n"); resubmit(); fprintf(cgiOut, "<input type=\"submit\" value=\">>\" />"); fprintf(cgiOut, "</form>"); fprintf(cgiOut, "</th>\n"); // goto page number fprintf(cgiOut, "<th width=\"120\">\n"); fprintf(cgiOut, "<form class=\"setpage\" action=\"certsearch.cgi\" method=\"post\">\n"); fprintf(cgiOut, "<input type=\"hidden\" name=\"certcounter\" "); fprintf(cgiOut, "value=\""); fprintf(cgiOut, "%d", certcounter); fprintf(cgiOut, "\" />\n"); fprintf(cgiOut, "<input type=\"hidden\" name=\"pagecounter\" "); fprintf(cgiOut, "value=\""); fprintf(cgiOut, "%d", pagecounter); fprintf(cgiOut, "\" />\n"); resubmit(); fprintf(cgiOut, "<input class=\"goto\" type=\"submit\" value=\"Goto\" />\n"); fprintf(cgiOut, " "); fprintf(cgiOut, "<input class=\"page\" type=\"text\" name=\"page\" "); fprintf(cgiOut, "value=\"%d\" />\n", pagecounter); fprintf(cgiOut, "</form>\n"); fprintf(cgiOut, "</th>\n"); fprintf(cgiOut, "</tr>\n"); fprintf(cgiOut, "</table>\n"); /* ---------------------------------------------------------------------------* * end the html output * * ---------------------------------------------------------------------------*/ pagefoot(); } return(0); }
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { int i,j,m,n; int ifield, jstruct, *classIDflags; int NStructElems, nfields, ndim, nsignal, nvals; const char *field_name, *str; const mxArray *field_array_ptr; double dbl; float *leadSnds[MAXCARRIERS], *lagSnds[MAXCARRIERS]; float *locations, *azimuths, *rove, *scalesLead, *scalesLag, *attensLead, *tmp; div_t div_result; InfoStruct recInfo; /* Check for proper number of arguments */ if (nrhs != 9) mexErrMsgTxt("9 input arguments required)."); else if(!mxIsStruct(prhs[0])) mexErrMsgTxt("Input1 must be a structure."); // deal with the structure (arg0) nfields = mxGetNumberOfFields(prhs[0]); NStructElems = mxGetNumberOfElements(prhs[0]); /* check each field. */ for(ifield=0; ifield<nfields; ifield++) { field_name = mxGetFieldNameByNumber(prhs[0], ifield); field_array_ptr = mxGetFieldByNumber(prhs[0], 0, ifield); if (field_array_ptr == NULL) mexPrintf(".%s is empty\n", field_name); else { str = mxArrayToString(field_array_ptr); dbl = mxGetScalar(field_array_ptr); if(strncmp("FN1", field_name, 3) == 0) strncpy(recInfo.outFN1, str, MAX_FILENAME_LEN); if (strncmp("FN2",field_name, 3) ==0) strncpy(recInfo.outFN2, str, MAX_FILENAME_LEN); if (strncmp("record",field_name, 6) ==0) recInfo.record = (unsigned int) dbl; if (strncmp("latten",field_name, 6) ==0) recInfo.latten = (float) dbl; if (strncmp("ratten",field_name, 6) ==0) recInfo.ratten = (float) dbl; if (strncmp("n_trials",field_name,8) ==0) recInfo.n_trials = (unsigned int) dbl; if (strncmp("decimateFactor",field_name, 14) ==0) recInfo.decimateFactor = (unsigned int) dbl; if (strncmp("buf_pts",field_name, 7) ==0) recInfo.buf_pts = (long) dbl; if (strncmp("nptsTotalPlay",field_name, 13) ==0) recInfo.nptsTotalPlay = (long) dbl; if (strncmp("ISI",field_name, 3) ==0) recInfo.ISI = (unsigned int) dbl; if (strncmp("max_signal_jitter",field_name, 17) ==0) recInfo.max_signal_jitter = (unsigned int) dbl; if (strncmp("num_carriers",field_name, 12) ==0) recInfo.num_carriers = (unsigned int) dbl; if (strncmp("n_speakers",field_name, 10) ==0) recInfo.n_speakers = (unsigned int) dbl; if (strncmp("sound_onset",field_name, 11) ==0) recInfo.sound_onset = (long) dbl; if (strncmp("trials_to_show",field_name, 14) ==0) recInfo.trials_to_show = (long) dbl; if (strncmp("hab_loc",field_name, 7) ==0) recInfo.hab_loc = (float) dbl; if (strncmp("test_trial_freq",field_name, 15) ==0) recInfo.test_trial_freq = (float) dbl; } } // check buf_pts = (n * 2^decimateFactor); div_result = div( recInfo.buf_pts, pow(2,recInfo.decimateFactor) ); if(div_result.rem) { recInfo.buf_pts = pow(2,recInfo.decimateFactor) * (div_result.quot +1); mexPrintf("buf_pts and decimateFactor incompatable. buf_pts increased to %d \n",recInfo.buf_pts); } // check nptsTotalPlay = (n * buf_pts) div_result = div( recInfo.nptsTotalPlay, recInfo.buf_pts ); if(div_result.rem) { recInfo.nptsTotalPlay = recInfo.buf_pts * (div_result.quot +1); mexPrintf("buf_pts and totalpts incompatable. nptsTotalPlay increased to %d \n",recInfo.nptsTotalPlay); } div_result = div( recInfo.nptsTotalPlay, (recInfo.buf_pts * (recInfo.ISI+1)) ); recInfo.n_trials = (int) div_result.quot +1; // get LEAD and LAG sounds (should be <= 50) // matlab arrays should be buf_pts x num_carriers // LEAD tmp=(float *) mxGetPr(prhs[1]); m=mxGetM(prhs[1]); n=mxGetN(prhs[1]); if(recInfo.buf_pts != m || recInfo.num_carriers != n) { mexPrintf("array is %i x %i",m,n); mexErrMsgTxt("Sound arrays must be buf_pts x num_carriers"); } for(i=0;i<recInfo.num_carriers;++i) leadSnds[i] = &tmp[i*recInfo.buf_pts]; // LEAD tmp=(float *) mxGetPr(prhs[2]); m=mxGetM(prhs[2]); n=mxGetN(prhs[2]); if(recInfo.buf_pts != m || recInfo.num_carriers != n) { mexPrintf("array is %i x %i",m,n); mexErrMsgTxt("Sound arrays must be buf_pts x num_carriers"); } for(i=0;i<recInfo.num_carriers;++i) lagSnds[i] = &tmp[i*recInfo.buf_pts]; // locations is a 1 x n (n>=n_trials) array of spkr positions to switch between (0-3) nsignal = mxGetN(prhs[3]); if ( mxGetM(prhs[3])!=1 || nsignal < recInfo.n_trials) mexErrMsgTxt("locations must be a 1 x n (n > n_trials), row vector."); locations = (float*) mxGetPr(prhs[3]); /* azimuths is a 1 x N array of azimuths (N = no. of speakers used) */ azimuths = (float*) mxGetPr(prhs[4]); // rove is a 1 x n (n>=n_trials) array of sound IDs for carrier roving nsignal = mxGetN(prhs[5]); if ( mxGetM(prhs[5])!=1 || nsignal < recInfo.n_trials) mexErrMsgTxt("rove sequence must be a 1 x n (n > n_trials), row vector."); rove = (float*) mxGetPr(prhs[5]); /* scalesLead is a 1 x (# lag speakers) array of scales for the lead speaker */ nvals = mxGetN(prhs[6]); if ( mxGetM(prhs[6])!=1 || nvals != (recInfo.n_speakers - 1) ) mexErrMsgTxt("scales for lead speaker must by 1 x (# lag speakers), row vector."); scalesLead = (float*) mxGetPr(prhs[6]); /* scalesLag is a 1 x (# lag speakers) array of scales for the lag speakers */ nvals = mxGetN(prhs[7]); if ( mxGetM(prhs[7])!=1 || nvals != (recInfo.n_speakers - 1) ) mexErrMsgTxt("scales for lag speaker must by 1 x (# lag speakers), row vector."); scalesLag = (float*) mxGetPr(prhs[7]); /* attensLead is a 1 x (# lag speakers) array of attens for the lead speaker */ nvals = mxGetN(prhs[8]); if ( mxGetM(prhs[8])!=1 || nvals != (recInfo.n_speakers - 1) ) mexErrMsgTxt("attens for the lead speaker must be a 1 x (# lag speakers), row vector."); attensLead = (float*) mxGetPr(prhs[8]); /* The double_buffer subroutine */ double_buffer( &recInfo, leadSnds, lagSnds, locations, azimuths, rove, scalesLead, scalesLag, attensLead, nsignal); return; }
int MatLab4LocateParam( char *file_name , char *param_name , char *time_name ) { int len ; int temp ; int endian ; int mat_size ; int mat_type ; int my_byte_order ; div_t div_result ; int row , column , imaginary ; char * temp_ptr ; bool param_found , time_found ; FILE *fp ; bool swap = false ; int size ; int y_field_num , time_field_num ; int max_offset , offset = 0 ; TRICK_GET_BYTE_ORDER(my_byte_order) ; if ((fp = fopen(file_name , "r")) == 0 ) { std::cerr << "ERROR: Couldn't open \"" << file_name << "\": " << std::strerror(errno) << std::endl; exit(-1) ; } // we use fseek calls to move around so I need to know the max offset of the file fseek( fp , 0 , SEEK_END ) ; max_offset = ftell(fp) ; rewind( fp ) ; // get field_num from param_name temp_ptr = rindex(param_name, '[') ; if ( temp_ptr != NULL ) { sscanf(&temp_ptr[1] , "%d" , &y_field_num ) ; } else { y_field_num = 0 ; } // get field_num from time_name temp_ptr = rindex(param_name, '[') ; if ( temp_ptr != NULL ) { sscanf(&temp_ptr[1] , "%d" , &time_field_num ) ; } else { time_field_num = 0 ; } param_found = time_found = false ; while ( offset < max_offset ) { // read the type in fread( &temp , 4 , 1 , fp ) ; if ( !strncmp( (char *)&temp , "MATL" , 4 )) { return(0) ; } // byte swap it if it looks like we need to if ( temp & 0xFFFF0000 ) { temp = trick_byteswap_int(temp) ; } div_result = div(temp , 1000) ; endian = div_result.quot ; temp = div_result.rem ; switch ( endian ) { case 0: swap = ( my_byte_order == TRICK_LITTLE_ENDIAN ) ? 0 : 1 ; break ; case 1: swap = ( my_byte_order == TRICK_BIG_ENDIAN ) ? 0 : 1 ; break ; default: fprintf(stderr,"Unknown endianness!\n") ; fclose(fp) ; return(0) ; break ; } div_result = div( temp , 10 ) ; mat_size = div_result.quot ; mat_type = div_result.rem ; switch ( mat_size ) { case 0: size = 8 ; break ; case 1: size = 4 ; break ; case 2: size = 4 ; break ; case 3: size = 2 ; break ; case 4: size = 2 ; break ; case 5: size = 1 ; break ; } fread( &row , 4 , 1 , fp ) ; if ( swap ) { row = trick_byteswap_int(row) ; } fread( &column , 4 , 1 , fp ) ; if ( swap ) { column = trick_byteswap_int(column) ; } fread( &imaginary , 4 , 1 , fp ) ; if ( swap ) { imaginary = trick_byteswap_int(imaginary) ; } fread( &len , 4 , 1 , fp ) ; if ( swap ) { len = trick_byteswap_int(len) ; } temp_ptr = new char[len +1] ; fread( temp_ptr , len , 1 , fp ) ; if ( ! strncmp( temp_ptr , param_name , len ) && y_field_num < column ) { param_found = true ; } if ( ! strncmp( temp_ptr , time_name , len ) && time_field_num < column ) { time_found = true ; } if ( mat_type != 0 ) { fprintf(stderr,"Unknown matrix type for %s\n", temp_ptr) ; } if ( param_found && time_found ) { fclose(fp) ; delete temp_ptr ; return(1) ; } delete temp_ptr ; // skip to next parameter fseek( fp , row * column * size * ( 1 + imaginary ) , SEEK_CUR ) ; offset = ftell(fp) ; } fclose(fp) ; return(0) ; }
ll incexc(vector<int> v, int i, int left, int lcmt){ if(left==0) return div(lcmt); if(i==v.size()) return 0; return (incexc(v, i+1, left, lcmt)+ ((left>0)? incexc(v, i+1, left-1, lcm(lcmt, v[i])) :0)) % MOD; }
int main(void) { char choice='x'; int a,b, exit=0; float fa,fb; do { printf("> "); fflush(stdin); scanf("%1s", &choice); switch(choice) { case '+': scanf("%d %d", &a, &b); printf("# %d\n",add(a,b)); break; case '-': scanf("%d %d", &a, &b); printf("# %d\n",sub(a,b)); break; case '/': scanf("%f %f", &fa, &fb); printf("# %.2f\n",div(fa, fb)); break; case 'd': scanf("%d %d", &a, &b); printf("# %d\n",iDiv(a,b)); break; case 'm': scanf("%d %d", &a, &b); printf("# %d\n",mod(a,b)); break; case '*': scanf("%d %d", &a, &b); printf("# %d\n",mul(a,b)); break; case '^': scanf("%d %d", &a,&b); printf("# %lld\n",nthPower(a, b)); break; case '!': scanf("%d", &a); printf("# %lld\n",fact(a)); break; case 's': scanf("%d", &a); printf("# %d\n",sum(a)); break; case 'a': scanf("%d", &a); printf("# %.2f\n",avg(a)); break; case 'c': scanf("%d %d", &a, &b); printf("# %lld\n",binom(a,b)); break; case 'p': scanf("%d", &a); if(prime(a)) printf("# y\n"); else printf("# n\n"); break; case 'q': exit = 1; break; default:printf("Unknown arguement: %c\n", choice); } } while(!exit); return 0; }
int zaFont::load_font(char * instr,int len) { char * pin = NULL; char * pout = NULL; char *p = NULL; char* inbuf = pin ; // m_filepos, file head char* outbuf = pout; if (len==0)// utf8, { int ll= strlen(instr); size_t inbytesleft= ll+1; size_t outbytesleft = inbytesleft*2; pin = (char *)malloc(inbytesleft); pout = (char *)malloc(outbytesleft); inbuf = pin ; // m_filepos, file head outbuf = pout; fprintf(stderr,"zaFont::load_font load begin length %d\n",ll); strcpy(pin,instr); iconv_t tt; tt = iconv_open("UTF-16LE","UTF-8"); int ret = iconv(tt,&inbuf,&inbytesleft,&outbuf,&outbytesleft); if ( ret < 0) { fprintf(stderr,"zaFont::load_font load error errno %d\n",errno); throw CException(__FILE__,__LINE__,"zaFont::load_font convert error ,filename %s","NULL"); } fprintf(stderr,"zaFont::load_font sucess.%d--%d:\n",ll*2,outbytesleft); iconv_close(tt); len = ll*2- outbytesleft; p= pout; } else p = instr; FT_Library library; FT_Face face; int c; int i, j; font_t* font = NULL; if(FT_Init_FreeType(&library)) { fprintf(stderr, "Error loading Freetype library\n"); return NULL; } if (FT_New_Face(library, m_path,0,&face)) { fprintf(stderr, "Error loading font %s\n", m_path); return NULL; } if(FT_Set_Char_Size ( face, m_size * 64, m_size * 64, m_dpi, m_dpi)) { fprintf(stderr, "Error initializing character parameters\n"); return NULL; } unsigned int charcode = 0; for (int cci =0 ; cci < len ; cci +=2) { charcode = ((unsigned char)*(p+1))*256+(unsigned char)*p ; if (charcode == 601) { charcode --; charcode ++; } if (this->m_map.find(charcode)==m_map.end()) { font = (font_t*) malloc(sizeof(font_t)); font->initialized = 0; glGenTextures(1, &(font->font_texture)); //Let each glyph reside in 32x32 section of the font texture int segment_size_x = 0, segment_size_y = 0; int num_segments_x = 1;//16 int num_segments_y = 1;//8 FT_GlyphSlot slot; FT_Bitmap bmp; int glyph_width, glyph_height; //First calculate the max width and height of a character in a passed font for(c = 0; c < 1; c++) { // if(FT_Load_Char(face,0x4E2D+charcode-0x4E2D , FT_LOAD_RENDER)) { fprintf(stderr, "FT_Load_Char failed\n"); free(font); return NULL; } slot = face->glyph; bmp = slot->bitmap; //glyph_width = nextp2(bmp.width); //glyph_height = nextp2(bmp.rows); glyph_width = bmp.width; glyph_height = bmp.rows; if (glyph_width > segment_size_x) { segment_size_x = glyph_width; } if (glyph_width > m_max_x) m_max_x = glyph_width; if (glyph_height > segment_size_y) { segment_size_y = glyph_height; } if (glyph_height > m_max_y) m_max_y = glyph_height; } int font_tex_width = nextp2(num_segments_x * segment_size_x); int font_tex_height = nextp2(num_segments_y * segment_size_y); int bitmap_offset_x = 0, bitmap_offset_y = 0; GLubyte* font_texture_data = (GLubyte*) malloc(sizeof(GLubyte) * 2 * font_tex_width * font_tex_height); memset((void*)font_texture_data, 0, sizeof(GLubyte) * 2 * font_tex_width * font_tex_height); if (!font_texture_data) { fprintf(stderr, "Failed to allocate memory for font texture\n"); free(font); return NULL; } // Fill font texture bitmap with individual bmp data and record appropriate size, texture coordinates and offsets for every glyph for(c = 0; c < 1; c++) { if(FT_Load_Char(face,0x4E2D+charcode-0x4E2D , FT_LOAD_RENDER)) { fprintf(stderr, "FT_Load_Char failed\n"); free(font); return NULL; } slot = face->glyph; bmp = slot->bitmap; glyph_width = nextp2(bmp.width); glyph_height = nextp2(bmp.rows); div_t temp = div(c, num_segments_x); bitmap_offset_x = segment_size_x * temp.rem; bitmap_offset_y = segment_size_y * temp.quot; for (j = 0; j < glyph_height; j++) { for (i = 0; i < glyph_width; i++) { font_texture_data[2 * ((bitmap_offset_x + i) + (j + bitmap_offset_y) * font_tex_width) + 0] = font_texture_data[2 * ((bitmap_offset_x + i) + (j + bitmap_offset_y) * font_tex_width) + 1] = (i >= bmp.width || j >= bmp.rows)? 0 : bmp.buffer[i + bmp.width * j]; } } font->advance[c] = (float)(slot->advance.x >> 6); font->tex_x1[c] = (float)bitmap_offset_x / (float) font_tex_width; font->tex_x2[c] = (float)(bitmap_offset_x + bmp.width) / (float)font_tex_width; font->tex_y1[c] = (float)bitmap_offset_y / (float) font_tex_height; font->tex_y2[c] = (float)(bitmap_offset_y + bmp.rows) / (float)font_tex_height; font->width[c] = bmp.width; font->height[c] = bmp.rows; font->offset_x[c] = (float)slot->bitmap_left; font->offset_y[c] = (float)((slot->metrics.horiBearingY-face->glyph->metrics.height) >> 6); } glBindTexture(GL_TEXTURE_2D, font->font_texture); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, font_tex_width, font_tex_height, 0, GL_LUMINANCE_ALPHA , GL_UNSIGNED_BYTE, font_texture_data); // fprintf(stderr, "charcode %d %d\n",charcode, cci); fflush(stderr); free(font_texture_data); font->initialized = 1; m_map[charcode] = font; } p += 2; }
int read_llb(h2fmi_read_boot_page_t read_page, int offset, int size, unsigned char *buf) { int rv = 0; int page = div(offset, LLB_PAGE_SIZE); /*offset / LLB_PAGE_SIZE*/ int start = offset - page * LLB_PAGE_SIZE; /*offset % LLB_PAGE_SIZE*/ #if 0 unsigned char *tmp = malloc_(4096); if (!tmp) { return -1; } for (page += 2; size > 0; page++) { int chunk = size; if (chunk > LLB_PAGE_SIZE - start) { chunk = LLB_PAGE_SIZE - start; } rv = read_page(0, page, tmp); if (rv) { break; } memcpy(buf, tmp + start, chunk); start = 0; buf += chunk; size -= chunk; } #else /* XXX more efficient, but should be used ONLY if read_page reads exactly LLB_PAGE_SIZE bytes */ unsigned char *tmp = NULL; page += 2; if (start) { int chunk = LLB_PAGE_SIZE - start; if (!(tmp = malloc_(LLB_PAGE_SIZE))) return -1; rv = read_page(0, page, tmp); if (rv) { goto err; } memcpy(buf, tmp + start, chunk); buf += chunk; size -= chunk; page++; } for (; size >= LLB_PAGE_SIZE; page++) { rv = read_page(0, page, buf); if (rv) { goto err; } buf += LLB_PAGE_SIZE; size -= LLB_PAGE_SIZE; } if (size) { if (!tmp && !(tmp = malloc_(LLB_PAGE_SIZE))) return -1; rv = read_page(0, page, tmp); if (rv == 0) { memcpy(buf, tmp, size); } } err: #endif free_(tmp); return rv; }
bigint& operator %=(const bigint& x){ div(x); return *this; }
// decode header void flexframesync_decode_header(flexframesync _q) { #if DEMOD_HEADER_SOFT // soft decoding operates on 'header_mod' array directly; // no need to pack bits #else // pack 256 1-bit header symbols into 32 8-bit bytes unsigned int num_written; liquid_pack_bytes(_q->header_mod, FLEXFRAME_H_SYM, _q->header_enc, FLEXFRAME_H_ENC, &num_written); assert(num_written==FLEXFRAME_H_ENC); #endif #if DEBUG_FLEXFRAMESYNC_PRINT unsigned int i; // print header (encoded) printf("header rx (enc) : "); for (i=0; i<FLEXFRAME_H_ENC; i++) printf("%.2X ", _q->header_enc[i]); printf("\n"); #endif // unscramble header and run packet decoder #if DEMOD_HEADER_SOFT // soft demodulation operates on header_mod directly unscramble_data_soft(_q->header_mod, FLEXFRAME_H_ENC); _q->header_valid = packetizer_decode_soft(_q->p_header, _q->header_mod, _q->header); #else unscramble_data(_q->header_enc, FLEXFRAME_H_ENC); _q->header_valid = packetizer_decode(_q->p_header, _q->header_enc, _q->header); #endif // return if header is invalid if (!_q->header_valid) return; // first several bytes of header are user-defined unsigned int n = FLEXFRAME_H_USER; // first byte is for expansion/version validation if (_q->header[n+0] != FLEXFRAME_VERSION) { fprintf(stderr,"warning: flexframesync_decode_header(), invalid framing version\n"); _q->header_valid = 0; return; } // strip off payload length unsigned int payload_dec_len = (_q->header[n+1] << 8) | (_q->header[n+2]); _q->payload_dec_len = payload_dec_len; // strip off modulation scheme/depth unsigned int mod_scheme = _q->header[n+3]; // strip off CRC, forward error-correction schemes // CRC : most-significant 3 bits of [n+4] // fec0 : least-significant 5 bits of [n+4] // fec1 : least-significant 5 bits of [n+5] unsigned int check = (_q->header[n+4] >> 5 ) & 0x07; unsigned int fec0 = (_q->header[n+4] ) & 0x1f; unsigned int fec1 = (_q->header[n+5] ) & 0x1f; // validate properties if (mod_scheme == 0 || mod_scheme >= LIQUID_MODEM_NUM_SCHEMES) { fprintf(stderr,"warning: flexframesync_decode_header(), invalid modulation scheme\n"); _q->header_valid = 0; return; } if (check >= LIQUID_CRC_NUM_SCHEMES) { fprintf(stderr,"warning: flexframesync_decode_header(), decoded CRC exceeds available\n"); _q->header_valid = 0; return; } if (fec0 >= LIQUID_FEC_NUM_SCHEMES) { fprintf(stderr,"warning: flexframesync_decode_header(), decoded FEC (inner) exceeds available\n"); _q->header_valid = 0; return; } if (fec1 >= LIQUID_FEC_NUM_SCHEMES) { fprintf(stderr,"warning: flexframesync_decode_header(), decoded FEC (outer) exceeds available\n"); _q->header_valid = 0; return; } // configure payload receiver if (_q->header_valid) { // recreate modem _q->ms_payload = mod_scheme; _q->bps_payload = modulation_types[mod_scheme].bps; _q->demod_payload = modem_recreate(_q->demod_payload, _q->ms_payload); // set new packetizer properties _q->check = check; _q->fec0 = fec0; _q->fec1 = fec1; // recreate packetizer object _q->p_payload = packetizer_recreate(_q->p_payload, _q->payload_dec_len, _q->check, _q->fec0, _q->fec1); // re-compute payload encoded message length _q->payload_enc_len = packetizer_get_enc_msg_len(_q->p_payload); // re-compute number of modulated payload symbols div_t d = div(8*_q->payload_enc_len, _q->bps_payload); _q->payload_mod_len = d.quot + (d.rem ? 1 : 0); // re-allocate buffers accordingly // (give encoded a few extra bytes to compensate for repacking) _q->payload_mod = (unsigned char*) realloc(_q->payload_mod, (_q->payload_mod_len )*sizeof(unsigned char)); _q->payload_enc = (unsigned char*) realloc(_q->payload_enc, (_q->payload_enc_len+8)*sizeof(unsigned char)); _q->payload_dec = (unsigned char*) realloc(_q->payload_dec, (_q->payload_dec_len )*sizeof(unsigned char)); if (_q->payload_mod == NULL || _q->payload_enc == NULL || _q->payload_dec == NULL) { fprintf(stderr,"error: flexframesync_decode_header(), could not re-allocate payload arrays\n"); _q->header_valid = 0; return; } } #if DEBUG_FLEXFRAMESYNC_PRINT // print results printf("flexframesync_decode_header():\n"); printf(" header crc : %s\n", _q->header_valid ? "pass" : "FAIL"); printf(" check : %s\n", crc_scheme_str[check][1]); printf(" fec (inner) : %s\n", fec_scheme_str[fec0][1]); printf(" fec (outer) : %s\n", fec_scheme_str[fec1][1]); printf(" mod scheme : %s\n", modulation_types[mod_scheme].name); printf(" payload dec len : %u\n", _q->payload_dec_len); printf(" payload enc len : %u\n", _q->payload_enc_len); printf(" payload mod len : %u\n", _q->payload_mod_len); printf(" user data :"); for (i=0; i<FLEXFRAME_H_USER; i++) printf(" %.2x", _q->header[i]); printf("\n"); #endif }
/************************** //Paillier HE system //len: length of params p,q **************************/ void Paillier(int len=512){ ZZ n, n2, p, q, g, lamda; ZZ p1, q1, p1q1; ZZ miu; ZZ m1, m2; ZZ BSm, HEm; //baseline and HE result ZZ c, c1, c2, cm1, cm2, r; //key gen start = std::clock(); GenPrime(p, len); GenPrime(q, len); mul(n, p, q); mul(n2, n, n); sub(p1,p,1); sub(q1,q,1); GCD(lamda,p1,q1); mul(p1q1,p1,q1); div(lamda, p1q1, lamda); RandomBnd(g, n2); PowerMod(miu,g,lamda,n2); sub(miu, miu, 1); div(miu,miu,n); //should add 1? InvMod(miu, miu, n); duration = ( std::clock() - start ) / (double) CLOCKS_PER_SEC; cout<<"Pailler Setup:"<< duration <<'\n'; //Enc start = std::clock(); RandomBnd(m1,n); RandomBnd(m2,n); RandomBnd(r,n); //enc m1 PowerMod(c1, g,m1,n2); PowerMod(c2, r,n,n2); MulMod(cm1, c1,c2, n2); RandomBnd(r,n); //enc m2 PowerMod(c1, g,m2,n2); PowerMod(c2, r,n,n2); MulMod(cm2, c1,c2, n2); duration = ( std::clock() - start ) / (double) CLOCKS_PER_SEC; cout<<"Pailler Enc:"<< duration/2 <<'\n'; //Evaluation start = std::clock(); c=cm1; for(int i=0; i<TIMES; i++) MulMod(c,c,cm2,n2); duration = ( std::clock() - start ) / (double) CLOCKS_PER_SEC; cout<<"Pailler Eval:"<< duration <<'\n'; //c=cm2; //Dec start = std::clock(); PowerMod(c,c,lamda,n2); sub(c,c,1); div(c,c,n); //should add 1? MulMod(HEm, c, miu, n); duration = ( std::clock() - start ) / (double) CLOCKS_PER_SEC; cout<<"Pailler Dec:"<< duration <<'\n'; //baseline BSm=m1; for(int i=0; i<TIMES; i++) AddMod(BSm,BSm,m2,n); assert(BSm==HEm); }
bigint& operator /=(const bigint& x){ return *this = div(x); }
int main() { char buffer[150]; char command[50]; char fileName2[50]; char result[13000]; char fileName1[25]; char fileName1Tmp[25]; char terminateString[3]; int i, j, c; terminateString[0] = 0xd; terminateString[1] = 0xa; terminateString[2] = '\0'; while(1) { interrupt(0x21, 0, "Shell:>\0", 0, 0); interrupt(0x21, 1, buffer, 0, 0); i = 0; j = 0; //read the command from the buffer while(buffer[i] != ' ' && buffer[i] != 0xd) command[j++] = buffer[i++]; command[j] = '\0'; j = 0; //make the pointer point to first character of fileName1 in the buffer if(buffer[i] == ' ') ++i; //read fileName1 from the buffer while(buffer[i] != ' ' && buffer[i] != 0xd) { fileName1[j] = buffer[i]; fileName1Tmp[j++] = buffer[i++]; } fileName1[j] = '\0'; fileName1Tmp[j] = '\0'; j = 0; //make the pointer point to first character of fileName2 in the buffer if(buffer[i] == ' ') ++i; //read fileName2 from the buffer while(buffer[i] != ' ' && buffer[i] != 0xd) fileName2[j++] = buffer[i++]; fileName2[j] = '\0'; //process view command if(equal("view\0", command)) { //check if the file name is entered if(fileName1[0] == '\0') { interrupt(0x21, 0, "No file entered", 0, 0); interrupt(0x21, 0, terminateString, 0, 0); continue; } interrupt(0x21, 3, fileName1, result, 0); //check if the file exists or not if(equal("Error!\0", result)) { interrupt(0x21, 0, "File not found", 0, 0); interrupt(0x21, 0, terminateString, 0, 0); } else { //print the file followed by a new line and carriage return interrupt(0x21, 0, result, 0, 0); interrupt(0x21, 0, terminateString, 0, 0); } } //process the execute command else if(equal("execute\0", command)) { //check if the file name is entered if(fileName1[0] == '\0') { interrupt(0x21, 0, "No file entered", 0, 0); interrupt(0x21, 0, terminateString, 0, 0); continue; } //read the file to check if file exists or not interrupt(0x21, 3, fileName1, result, 0); if(equal("Error!\0", result)) { interrupt(0x21, 0, "File not found", 0, 0); interrupt(0x21, 0, terminateString, 0, 0); } else interrupt(0x21, 4, fileName1, 0x2000, 0); } //process the delete command else if(equal("delete\0", command)) { //check if the file name is entered if(fileName1[0] == '\0') { interrupt(0x21, 0, "No file entered", 0, 0); interrupt(0x21, 0, terminateString, 0, 0); continue; } //read the file to check if the file exists or not interrupt(0x21, 3, fileName1, result, 0); if(equal("Error!\0", result)) { interrupt(0x21, 0, "File not found", 0, 0); interrupt(0x21, 0, terminateString, 0, 0); } else{ interrupt(0x21, 7, fileName1, 0, 0); } } //process the copy command else if(equal("copy\0", command)) { //check if the file 1 name is entered if(fileName1[0] == '\0') { interrupt(0x21, 0, "File 1 not entered", 0, 0); interrupt(0x21, 0, terminateString, 0, 0); continue; } //check if the file 2 name is entered else if(fileName2[0] == '\0') { interrupt(0x21, 0, "File 2 not entered", 0, 0); interrupt(0x21, 0, terminateString, 0, 0); continue; } //read the file interrupt(0x21, 3, fileName1, result, 0); //check if the file exists if(equal("Error!\0", result)) { interrupt(0x21, 0, "File not found", 0, 0); interrupt(0x21, 0, terminateString, 0, 0); } else{ //count the number of sectors for(j = 0; result[j] != '\0'; j++); j = div(j+511,512); interrupt(0x21, 8, fileName2, result, j); } } //process the dir command else if(equal("dir\0", command)) { interrupt(0x21,9,result,0,0); interrupt(0x21, 0, result, 0, 0); interrupt(0x21, 0, terminateString, 0, 0); } //process the create command else if(equal("create\0", command)) { //check if the file name is entered if(fileName1[0] == '\0') { interrupt(0x21, 0, "No name entered", 0, 0); interrupt(0x21, 0, terminateString, 0, 0); continue; } else { c=0; //read the first line into the buffer interrupt(0x21, 1, buffer, 0, 0); //terminate the loop if the first character in the line is 0xd (carriage return) while(buffer[0] != 0xd ) { //copy the buffer into the result for (j = 0; buffer[j] != '\0'; ++j) { result[c++] = buffer[j]; } //read the new line into the buffer interrupt(0x21, 1, buffer, 0, 0); } result[c-2] = '\0'; interrupt(0x21,8,fileName1,result,1); } } else { //no valid command is entered interrupt(0x21, 0, "Bad command", 0, 0); interrupt(0x21, 0, terminateString, 0, 0); } } }
int parse_args(int argc, char **argv, arguments_t *a) { int i; time_t systime; unsigned long long curr_time; #ifndef _MSC_VER char *ep; #endif unsigned int tmp_max_sb_len; unsigned int tmp_es_len; char *tmp_addr; unsigned char fec_enc; char *tmp_base_dir; char *tmp_repair; BOOL repair; unsigned long long tmp_tsi; unsigned long long duration; char *loss_ratio2; div_t div_max_k; div_t div_max_n; time(&systime); curr_time = systime + 2208988800U; tmp_tsi = DEF_TSI; /* transport session identifier */ tmp_max_sb_len = 0; tmp_es_len = 0; tmp_addr = NULL; fec_enc = DEF_FEC; tmp_base_dir = NULL; tmp_repair = NULL; repair = FALSE; loss_ratio2 = NULL; duration = 0; a->toi = 0; /* transport object identifier */ a->cont = FALSE; /* continuous transmission */ a->rx_automatic = FALSE; /* download files defined in IDT automatically */ a->rx_object = FALSE; a->file_table_output = FALSE; a->log_fd = -1; a->complete_fdt = 0; a->send_session_close_packets = 1; a->name_incomplete_objects = FALSE; #ifdef _MSC_VER a->open_file = FALSE; /* open received file automatically */ #endif memset(a->sdp_file, 0, MAX_PATH_LENGTH); memset(a->file_path, 0, MAX_PATH_LENGTH); /* file(s) or directory to send */ memset(a->fdt_file, 0, MAX_PATH_LENGTH); strcpy(a->fdt_file, DEF_FDT); /* fdt file (fdt based send) */ a->alc_a.cc_id = DEF_CC; /* congestion control */ a->alc_a.mode = RECEIVER; /* sender or receiver? */ a->alc_a.port = DEF_MCAST_PORT; /* local port number for base channel */ a->alc_a.nb_channel = DEF_NB_CHANNEL; /* number of channels */ a->alc_a.intface = NULL; /* interface */ a->alc_a.intface_name = NULL; /* interface name/index for IPv6 multicast join */ a->alc_a.addr_family = DEF_ADDR_FAMILY; a->alc_a.addr_type = 0; a->alc_a.es_len = DEF_SYMB_LENGTH; /* encoding symbol length */ a->alc_a.max_sb_len = DEF_MAX_SB_LEN; /* source block length */ a->alc_a.tx_rate = DEF_TX_RATE; /* transmission rate in kbit/s */ a->alc_a.ttl = DEF_TTL; /* time to live */ a->alc_a.nb_tx = DEF_TX_NB; /* nb of time to send the file/directory */ a->alc_a.simul_losses = FALSE; /* simulate packet losses */ a->alc_a.loss_ratio1 = P_LOSS_WHEN_OK; a->alc_a.loss_ratio2 = P_LOSS_WHEN_LOSS; a->alc_a.fec_ratio = DEF_FEC_RATIO; /* FEC ratio percent */ a->alc_a.fec_enc_id = DEF_FEC_ENC_ID; /* FEC Encoding */ a->alc_a.fec_inst_id = DEF_FEC_INST_ID; a->alc_a.rx_memory_mode = 1; a->alc_a.verbosity = 1; a->alc_a.use_fec_oti_ext_hdr = 0; /* include fec oti extension header to flute header */ a->alc_a.encode_content = 0; /* encode content */ a->alc_a.src_addr = NULL; a->alc_a.optimize_tx_rate = FALSE; a->alc_a.calculate_session_size = FALSE; a->alc_a.half_word = FALSE; a->alc_a.accept_expired_fdt_inst = FALSE; #ifdef SSM a->alc_a.use_ssm = FALSE; /* use source specific multicast */ #endif if(strstr(argv[0], "repair_sender")) { a->alc_a.mode = SENDER; repair = TRUE; } else { a->alc_a.mode = RECEIVER; } for(i = 1; i < argc ; i++) { if(argv[i][0] == '-') { switch(argv[i][1]) { case 'A': /* automatic download */ if(strlen(argv[i]) > 2) { return -1; } a->rx_automatic = TRUE; break; case 'a': /* address family */ if(strlen(argv[i]) > 3) { if(!(strcmp(&argv[i][3], "IPv4"))) { a->alc_a.addr_family = PF_INET; } else if(!(strcmp(&argv[i][3], "IPv6"))) { a->alc_a.es_len = MAX_SYMB_LENGTH_IPv6_FEC_ID_0_3_130; a->alc_a.addr_family = PF_INET6; } } else { return -1; } break; case 'B': /* base directory for downloaded files */ if(strlen(argv[i]) > 3) { tmp_base_dir = &argv[i][3]; } else { return -1; } break; case 'b': /* rx_memory_mode */ if(strlen(argv[i]) > 3) { a->alc_a.rx_memory_mode = (unsigned char)atoi(&argv[i][3]); if(a->alc_a.rx_memory_mode > 2) { printf("Possible values for option -b are: 0, 1, or 2\n"); fflush(stdout); return -1; } } else { return -1; } break; case 'C': /* Continuous transmission */ if(strlen(argv[i]) > 2) { return -1; } a->cont = TRUE; break; case 'c': /* number of channels */ if(strlen(argv[i]) > 3) { a->alc_a.nb_channel = (unsigned char)atoi(&argv[i][3]); if(a->alc_a.nb_channel > MAX_CHANNELS_IN_SESSION) { printf("Channel number set to maximum value: %i\n", MAX_CHANNELS_IN_SESSION); a->alc_a.nb_channel = MAX_CHANNELS_IN_SESSION; } else if(a->alc_a.nb_channel == 0) { printf("Channel number set to 1\n"); a->alc_a.nb_channel = 1; } } else { return -1; } break; case 'D': /* session duration time */ if(strlen(argv[i]) > 3) { #ifdef _MSC_VER duration = _atoi64(&argv[i][3]); if(duration > (unsigned long long)0xFFFFFFFFFFFFFFFF) { printf("Duration: %I64u too big (max=%I64u)\n", duration, (unsigned long long)0xFFFFFFFFFFFFFFFF); fflush(stdout); return -1; } #else duration = strtoull(&argv[i][3], &ep, 10); if(&argv[i][3] == '\0' || *ep != '\0') { printf("Duration not a number\n"); fflush(stdout); return -1; } if(errno == ERANGE && duration == 0xFFFFFFFFFFFFFFFFULL) { printf("Duration too big for unsigned long long (64 bits)\n"); fflush(stdout); return -1; } #endif } else { return -1; } break; case 'd': /* sdp file */ if(strlen(argv[i]) <= 3) { return -1; } else if(strlen(argv[i]) >= MAX_PATH_LENGTH) { printf("\nFile path for SDP file too long\n"); return -1; } else { memset(a->sdp_file, 0, MAX_PATH_LENGTH); strcpy(a->sdp_file, &argv[i][3]); } break; case 'E': /* Accept Expired FDT Instances */ if(strlen(argv[i]) > 2) { return -1; } a->alc_a.accept_expired_fdt_inst = TRUE; break; case 'e': /* Use fec oti extension header */ if(strlen(argv[i]) > 3) { a->alc_a.use_fec_oti_ext_hdr = (unsigned char)atoi(&argv[i][3]); if(a->alc_a.use_fec_oti_ext_hdr > 1) { printf("Possible values for option -e are: 0, or 1\n"); fflush(stdout); return -1; } } else { return -1; } break; case 'F': /* files or directories to send/receive */ if(strlen(argv[i]) <= 3) { return -1; } else if(strlen(argv[i]) >= MAX_PATH_LENGTH) { printf("\nFile path for files or directories too long\n"); return -1; } else { memset(a->file_path, 0, MAX_PATH_LENGTH); strcpy(a->file_path, &argv[i][3]); } memset(a->fdt_file, 0, MAX_PATH_LENGTH); break; case 'f': /* fdt based send */ if(strlen(argv[i]) <= 3) { return -1; } else if(strlen(argv[i]) >= MAX_PATH_LENGTH) { printf("\nFile path for FDT file too long\n"); return -1; } else { memset(a->fdt_file, 0, MAX_PATH_LENGTH); strcpy(a->fdt_file, &argv[i][3]); } memset(a->file_path, 0, MAX_PATH_LENGTH); break; case 'G': /* Calculate session size but do not send anything */ if(strlen(argv[i]) > 2) { return -1; } a->alc_a.calculate_session_size = TRUE; break; case 'H': /* use half-word */ if(strlen(argv[i]) > 2) { return -1; } a->alc_a.half_word = TRUE; break; case 'h': /* help/usage */ return -1; break; case 'I': /* local interface name/index for IPv6 multicast join */ if(strlen(argv[i]) > 3) { a->alc_a.intface_name = &argv[i][3]; } else { return -1; } break; case 'i': /* local interface to use */ if(strlen(argv[i]) > 3) { a->alc_a.intface = &argv[i][3]; } else { return -1; } break; //Malek El Khatib 14.05.2014 //Start //User could customize name of output log file case 'J': /* local interface to use */ if(strlen(argv[i]) <= 3) { return -1; } else if(strlen(argv[i]) >= MAX_PATH_LENGTH) { printf("\nFile path for log file too long\n"); return -1; } else { logFile=&argv[i][3]; } break; //End case 'K': /* 'repair_sender.conf' */ if(strlen(argv[i]) <= 3) { return -1; } else if(strlen(argv[i]) >= MAX_PATH_LENGTH) { printf("\nFile path for repair sender configuration file too long\n"); return -1; } else { tmp_repair = &argv[i][3]; } break; case 'k': /* Complete FDT */ if(strlen(argv[i]) > 3) { a->complete_fdt = (unsigned short)atoi(&argv[i][3]); } else { return -1; } break; case 'L': /* sbl length */ if(strlen(argv[i]) > 3) { tmp_max_sb_len = (unsigned int)atoi(&argv[i][3]); } else { return -1; } break; case 'l': /* encoding symbol length */ if(strlen(argv[i]) > 3) { tmp_es_len = (unsigned short)atoi(&argv[i][3]); } else { return -1; } break; #ifdef SSM case 'M': /* use source specific multicast */ if(strlen(argv[i]) > 2) { return -1; } a->alc_a.use_ssm = TRUE; break; case 'm': /* Multicast group for base channel */ if(strlen(argv[i]) > 3) { tmp_addr = &argv[i][3]; } else { return -1; } break; #endif case 'N': if(strlen(argv[i]) > 2) { return -1; } a->name_incomplete_objects = TRUE; break; case 'n': /* tx loops */ if(strlen(argv[i]) > 3) { a->alc_a.nb_tx = (unsigned short)atoi(&argv[i][3]); } else { return -1; } break; #ifdef _MSC_VER case 'O': /* automatic opening */ if(strlen(argv[i]) > 2) { return -1; } a->open_file = TRUE; break; #endif case 'o': /* toi */ if(strlen(argv[i]) > 3) { #ifdef _MSC_VER a->toi = _atoi64(&argv[i][3]); if(a->toi > (unsigned long long)0xFFFFFFFFFFFFFFFF) { printf("TOI: %I64u too big (max=%I64u)\n", a->toi, (unsigned long long)0xFFFFFFFFFFFFFFFF); fflush(stdout); return -1; } #else a->toi = strtoull(&argv[i][3], &ep, 10); if(&argv[i][3] == '\0' || *ep != '\0') { printf("TOI not a number\n"); fflush(stdout); return -1; } if(errno == ERANGE && a->toi == 0xFFFFFFFFFFFFFFFFULL) { printf("TOI too big for unsigned long long (64 bits)\n"); fflush(stdout); return -1; } #endif a->rx_object = 1; } else { return -1; } break; case 'P': /* simulate packet losses */ if(strlen(argv[i]) >= 2) { a->alc_a.simul_losses = TRUE; } if(strlen(argv[i]) > 3) { a->alc_a.loss_ratio1 = atof(strtok(&argv[i][3], ",")); loss_ratio2 = strtok(NULL, "\0"); if(loss_ratio2 == NULL) { return -1; } a->alc_a.loss_ratio2 = atof(loss_ratio2); } if(strlen(argv[i]) == 3) { return -1; } break; case 'p': /* Port number for base channel*/ if(strlen(argv[i]) > 3) { a->alc_a.port = &argv[i][3]; assert(atoi(a->alc_a.port) > 0); assert(atoi(a->alc_a.port) <= 0xFFFF); } else { return -1; } break; case 'q': /* Send session close packets */ if(strlen(argv[i]) > 3) { a->send_session_close_packets = atoi(&argv[i][3]); } else { return -1; } break; //Malek El Khatib 16.7.2014 //Start case 'Q': /* Send/Receive FDT after object */ if(strlen(argv[i]) > 2) { return -1; } sendFDTAfterObj = TRUE; break; //END #ifdef USE_FILE_REPAIR case 'R': /* 'apd.xml' or 'flute.conf' */ if(strlen(argv[i]) == 3) { return -1; } else if(strlen(argv[i]) >= MAX_PATH_LENGTH) { printf("\nFile path for repair configuration file too long\n"); return -1; } else if(strlen(argv[i]) == 2) { repair = TRUE; } else { repair = TRUE; tmp_repair = &argv[i][3]; } break; #endif case 'r': /* Transmission rate in kbits/s */ if(strlen(argv[i]) > 3) { a->alc_a.tx_rate = (unsigned int)atoi(&argv[i][3]); } else { return -1; } break; case 'S': /* sender */ if(strlen(argv[i]) > 2) { return -1; } a->alc_a.mode = SENDER; a->toi = FDT_TOI; break; case 's': /* first alc session identifier */ if(strlen(argv[i]) > 3) { a->alc_a.src_addr = &argv[i][3]; } else { return -1; } break; case 'T': /* ttl */ if(strlen(argv[i]) > 3) { a->alc_a.ttl = (unsigned char)atoi(&argv[i][3]); } else { return -1; } break; case 't': /* second alc session identifier */ if(strlen(argv[i]) > 3) { #ifdef _MSC_VER tmp_tsi = _atoi64(&argv[i][3]); #else tmp_tsi = strtoull(&argv[i][3], &ep, 10); if(&argv[i][3] == '\0' || *ep != '\0') { printf("TSI not a number\n"); fflush(stdout); return -1; } if(errno == ERANGE && tmp_tsi == 0xFFFFFFFFFFFFFFFFULL) { printf("TSI too big for unsigned long long (64 bits)\n"); fflush(stdout); return -1; } #endif #ifdef _MSC_VER if(tmp_tsi > (unsigned long long)0xFFFFFFFFFFFF) { printf("TSI: %I64u too big (max=%I64u)\n", tmp_tsi, (unsigned long long)0xFFFFFFFFFFFF); #else if(tmp_tsi > 0xFFFFFFFFFFFFULL) { printf("TSI: %llu too big (max=%llu)\n", tmp_tsi, 0xFFFFFFFFFFFFULL); #endif fflush(stdout); return -1; } } else { return -1; } break; case 'U': /* unicast address */ if(strlen(argv[i]) > 2) { return -1; } a->alc_a.addr_type = 1; break; case 'V': /* redirect stderr and stdout into given file */ if (strlen(argv[i]) > 3) { #ifdef _MSC_VER a->log_fd = _open(&argv[i][3], _O_RDWR | _O_CREAT | _O_TRUNC, 0666); #else a->log_fd = open(&argv[i][3], O_RDWR | O_CREAT | O_TRUNC, 0666); #endif if(a->log_fd < 0) { printf("Log file: %s cannot be opened\n", &argv[i][3]); fflush(stdout); return -1; } #ifdef _MSC_VER _dup2(a->log_fd, _fileno(stdout)); _dup2(a->log_fd, _fileno(stderr)); #else dup2(a->log_fd, fileno(stdout)); dup2(a->log_fd, fileno(stderr)); #endif } break; case 'v': /* verbosity level */ if(strlen(argv[i]) > 3) { a->alc_a.verbosity = atoi(&argv[i][3]); if(a->alc_a.verbosity > 4) { printf("Possible values for option -v are: 0, 1, 2, 3, or 4\n"); fflush(stdout); return -1; } } else { return -1; } break; case 'W': /* File table output */ if(strlen(argv[i]) > 2) { return -1; } a->file_table_output = TRUE; break; case 'w': /* congestion control */ if(strlen(argv[i]) > 3) { a->alc_a.cc_id = (unsigned char)atoi(&argv[i][3]); if(a->alc_a.cc_id > 1) { printf("Possible values for option -w are: 0, or 1\n"); fflush(stdout); return -1; } } else { return -1; } break; case 'X': /* FEC ratio percent */ if(strlen(argv[i]) > 3) { a->alc_a.fec_ratio = (unsigned short)atoi(&argv[i][3]); } else { return -1; } break; case 'x': /* fec encoding */ if(strlen(argv[i]) > 3) { fec_enc = (unsigned char)atoi(&argv[i][3]); if(fec_enc > 3) { printf("Possible values for option -x are: 0, 1, 2 or 3\n"); fflush(stdout); return -1; } } else { return -1; } break; //Malek El Khatib 16.04.2014 //START //Add file to indicate absolute sending times case 'y': if(strlen(argv[i]) <= 3) { return -1; } else if(strlen(argv[i]) >= MAX_PATH_LENGTH) { printf("\nFile path for input file too long\n"); return -1; } else { sendingTimesFile=&argv[i][3]; } break; //End //Indicate the number of es per packet. Zero indicates that file -y:str is used which determines the chunks to send at a time. Maximum data per packet will then be used case 'Y': if(strlen(argv[i]) > 3) { numEncSymbPerPacket = strtoul(&argv[i][3], &ep, 10); if(&argv[i][3] == '\0' || *ep != '\0') { printf("Number of Encoding Symbols per packet is not a number or not a valid number\n"); fflush(stdout); return -1; } } else { return -1; } break; //END case 'Z': /* optimize transmission rate (use more CPU) */ if(strlen(argv[i]) > 2) { return -1; } a->alc_a.optimize_tx_rate = TRUE; break; case 'z': /* encode content */ if(strlen(argv[i]) > 3) { a->alc_a.encode_content = (unsigned char)atoi(&argv[i][3]); if(a->alc_a.encode_content > 3) { printf("Possible values for option -z are: 0, 1, 2 or 3\n"); fflush(stdout); return -1; } } else { return -1; } break; default: return -1; break; } } else { return -1; } } if(tmp_addr == NULL) { if(a->alc_a.addr_family == PF_INET) { tmp_addr = DEF_MCAST_IPv4_ADDR; } else if(a->alc_a.addr_family == PF_INET6) { tmp_addr = DEF_MCAST_IPv6_ADDR; } } a->alc_a.addr = tmp_addr; if(fec_enc == 1) { a->alc_a.fec_enc_id = SIMPLE_XOR_FEC_ENC_ID; if(a->alc_a.addr_family == PF_INET) { a->alc_a.es_len = MAX_SYMB_LENGTH_IPv4_FEC_ID_2_128_129; } else if(a->alc_a.addr_family == PF_INET6) { a->alc_a.es_len = MAX_SYMB_LENGTH_IPv6_FEC_ID_2_128_129; } } else if(fec_enc == 2) { a->alc_a.fec_enc_id = SB_SYS_FEC_ENC_ID; a->alc_a.fec_inst_id = REED_SOL_FEC_INST_ID; if(a->alc_a.addr_family == PF_INET) { a->alc_a.es_len = MAX_SYMB_LENGTH_IPv4_FEC_ID_2_128_129; } else if(a->alc_a.addr_family == PF_INET6) { a->alc_a.es_len = MAX_SYMB_LENGTH_IPv6_FEC_ID_2_128_129; } } else if(fec_enc == 3) { a->alc_a.fec_enc_id = RS_FEC_ENC_ID; } if(a->alc_a.mode == RECEIVER) { a->alc_a.tsi = tmp_tsi; memset(a->alc_a.base_dir, 0, MAX_PATH_LENGTH); if(tmp_base_dir == NULL) { strcpy(a->alc_a.base_dir, DEF_BASE_DIR); } else { strcpy(a->alc_a.base_dir, tmp_base_dir); } a->alc_a.start_time = curr_time; if(duration == 0) { a->alc_a.stop_time = curr_time + DEF_RECEIVER_TIMEOUT; } else { a->alc_a.stop_time = curr_time + duration; } #ifdef USE_FILE_REPAIR if(repair) { memset(a->repair, 0, MAX_PATH_LENGTH); if(tmp_repair == NULL) { strcpy(a->repair, DEF_APD_CONF_FILE); } else { strcpy(a->repair, tmp_repair); } } else { memset(a->repair, 0, MAX_PATH_LENGTH); } #endif } else { if(((a->alc_a.half_word == FALSE) && (tmp_tsi > 0xFFFFFFFF))) { printf("TSI too big for unsigned long (32 bits)\n"); fflush(stdout); return -1; } else { a->alc_a.tsi = tmp_tsi; } memset(a->alc_a.base_dir, 0, MAX_PATH_LENGTH); if(tmp_base_dir != NULL) { strcpy(a->alc_a.base_dir, tmp_base_dir); } a->alc_a.start_time = curr_time; if(duration == 0) { a->alc_a.stop_time = curr_time + DEF_SESSION_DURATION; } else { a->alc_a.stop_time = curr_time + duration; } #ifdef USE_FILE_REPAIR if(repair) { memset(a->repair, 0, MAX_PATH_LENGTH); if(tmp_repair == NULL) { strcpy(a->repair, DEF_FLUTE_CONF_FILE); } else { strcpy(a->repair, tmp_repair); } } else { memset(a->repair, 0, MAX_PATH_LENGTH); } #else if(repair) { memset(a->repair, 0, MAX_PATH_LENGTH); if(tmp_repair == NULL) { strcpy(a->repair, DEF_REPAIR_SENDER_CONF_FILE); } else { strcpy(a->repair, tmp_repair); } } else { memset(a->repair, 0, MAX_PATH_LENGTH); } #endif } if(tmp_max_sb_len != 0) { if(a->alc_a.fec_enc_id == COM_NO_C_FEC_ENC_ID) { if(tmp_max_sb_len > MAX_SB_LEN_NULL_FEC) { printf("Maximum source block length set to maximum value: %i\n", MAX_SB_LEN_NULL_FEC); fflush(stdout); tmp_max_sb_len = MAX_SB_LEN_NULL_FEC; } a->alc_a.max_sb_len = tmp_max_sb_len; } else if(a->alc_a.fec_enc_id == SIMPLE_XOR_FEC_ENC_ID) { if(tmp_max_sb_len > MAX_SB_LEN_SIMPLE_XOR_FEC) { printf("Maximum source block length set to maximum value: %i\n", MAX_SB_LEN_SIMPLE_XOR_FEC); fflush(stdout); tmp_max_sb_len = MAX_SB_LEN_SIMPLE_XOR_FEC; } a->alc_a.max_sb_len = tmp_max_sb_len; } else if(((a->alc_a.fec_enc_id == RS_FEC_ENC_ID) || ((a->alc_a.fec_enc_id == SB_SYS_FEC_ENC_ID) && (a->alc_a.fec_inst_id == REED_SOL_FEC_INST_ID)))) { div_max_n = div((tmp_max_sb_len * (100 + a->alc_a.fec_ratio)), 100); if(div_max_n.quot > MAX_N_REED_SOLOMON) { div_max_k = div((MAX_N_REED_SOLOMON * 100), (100 + a->alc_a.fec_ratio)); printf("Maximum source block length set to maximum value: %i\n", div_max_k.quot); fflush(stdout); tmp_max_sb_len = div_max_k.quot; } a->alc_a.max_sb_len = tmp_max_sb_len; } } if(tmp_es_len != 0) { if(a->alc_a.addr_family == PF_INET) { if(((a->alc_a.fec_enc_id == COM_NO_C_FEC_ENC_ID) || (a->alc_a.fec_enc_id == RS_FEC_ENC_ID) || (a->alc_a.fec_enc_id == COM_FEC_ENC_ID))) { if(tmp_es_len > MAX_SYMB_LENGTH_IPv4_FEC_ID_0_3_130) { printf("Encoding symbol length set to maximum value: %i\n", MAX_SYMB_LENGTH_IPv4_FEC_ID_0_3_130); fflush(stdout); tmp_es_len = MAX_SYMB_LENGTH_IPv4_FEC_ID_0_3_130; } } else if(((a->alc_a.fec_enc_id == SIMPLE_XOR_FEC_ENC_ID) || (a->alc_a.fec_enc_id == SB_LB_E_FEC_ENC_ID) || (a->alc_a.fec_enc_id == SB_SYS_FEC_ENC_ID))) { if(tmp_es_len > MAX_SYMB_LENGTH_IPv4_FEC_ID_2_128_129) { printf("Encoding symbol length set to maximum value: %i\n", MAX_SYMB_LENGTH_IPv4_FEC_ID_2_128_129); fflush(stdout); tmp_es_len = MAX_SYMB_LENGTH_IPv4_FEC_ID_2_128_129; } } } else if(a->alc_a.addr_family == PF_INET6) { if(((a->alc_a.fec_enc_id == COM_NO_C_FEC_ENC_ID) || (a->alc_a.fec_enc_id == RS_FEC_ENC_ID) || (a->alc_a.fec_enc_id == COM_FEC_ENC_ID))) { if(tmp_es_len > MAX_SYMB_LENGTH_IPv6_FEC_ID_0_3_130) { printf("Encoding symbol length set to maximum value: %i\n", MAX_SYMB_LENGTH_IPv6_FEC_ID_0_3_130); fflush(stdout); tmp_es_len = MAX_SYMB_LENGTH_IPv6_FEC_ID_0_3_130; } } else if(((a->alc_a.fec_enc_id == SIMPLE_XOR_FEC_ENC_ID) || (a->alc_a.fec_enc_id == SB_LB_E_FEC_ENC_ID) || (a->alc_a.fec_enc_id == SB_SYS_FEC_ENC_ID))) { if(tmp_es_len > MAX_SYMB_LENGTH_IPv6_FEC_ID_2_128_129) { printf("Encoding symbol length set to maximum value: %i\n", MAX_SYMB_LENGTH_IPv6_FEC_ID_2_128_129); fflush(stdout); tmp_es_len = MAX_SYMB_LENGTH_IPv6_FEC_ID_2_128_129; } } } a->alc_a.es_len = tmp_es_len; } if(((((a->rx_automatic == TRUE) || (a->alc_a.mode == SENDER))) && (a->file_table_output == TRUE))) { a->alc_a.verbosity = -1; } return 0; }
void StdlibDiv(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) { ReturnValue->Val->Integer = div(Param[0]->Val->Integer, Param[1]->Val->Integer); }
/* ceil_DIV(a,b) := ceil(a / b) in _int_ arithmetic : */ static R_INLINE int ceil_DIV(int a, int b) { div_t div_res = div(a, b); return div_res.quot + ((div_res.rem != 0) ? 1 : 0); }
void __CLRCALL_PURE_OR_CDECL _MP_Rem(_MP_arr u, _Max_type v0) { // divide multi-word value by value, leaving remainder in u _Max_type v[2]; v[0] = v0 & mask; v[1] = v0 >> shift; const int n = limit(v, 2); const int m = limit(u, _MP_len) - n; // Knuth, vol. 2, p. 272, Algorithm D // D1: [Normalize.] _Max_type d = max / (v[n - 1] + 1); if (d != 1) { // scale numerator and divisor mul(u, _MP_len, d); mul(v, n, d); } // D2: [Initialize j.] for (int j = m; 0 <= j; --j) { // D3: [Calculate qh.] _Max_type qh = ((u[j + n] << shift) + u[j + n - 1]) / v[n - 1]; if (qh == 0) continue; _Max_type rh = ((u[j + n] << shift) + u[j + n - 1]) % v[n - 1]; for (;;) if (qh < max && qh * v[n - 2] <= (rh << shift) + u[j + n - 2]) break; else { // reduce tentative value and retry --qh; rh += v[n - 1]; if (max <= rh) break; } // D4: [Multiply and subtract.] _Max_type k = 0; int i; for (i = 0; i < n; ++i) { // multiply and subtract u[j + i] -= qh * v[i] + k; k = u[j + i] >> shift; if (k) k = max - k; u[j + i] &= mask; } for (; k != 0 && j + i < _MP_len; ++i) { // propagate borrow u[j + i] -= k; k = u[j + i] >> shift; if (k) k = max - k; u[j + i] &= mask; } // D5: [Test remainder.] if (k != 0) { // D6: [Add back.] --qh; add(u + j, n + 1, v, n); } // D7: [Loop on j.] } // D8: [Unnormalize.] if (d != 1) div(u, d); }
static void find_empty_segs (PixelRegion *maskPR, gint scanline, gint empty_segs[], gint max_empty, gint *num_empty, BoundaryType type, gint x1, gint y1, gint x2, gint y2) { uint8_t* data; int x; int start, end; int val, last; int endx, l_num_empty; div_t d; data = NULL; start = 0; end = 0; *num_empty = 0; if (scanline < 0 || scanline >= maskPR->h) { empty_segs[(*num_empty)++] = 0; empty_segs[(*num_empty)++] = G_MAXINT; return; } if (type == WithinBounds) { if (scanline < y1 || scanline >= y2) { empty_segs[(*num_empty)++] = 0; empty_segs[(*num_empty)++] = G_MAXINT; return; } start = x1; end = x2; } else if (type == IgnoreBounds) { start = 0; end = maskPR->w; if (scanline < y1 || scanline >= y2) x2 = -1; } /* tilex = -1; */ empty_segs[(*num_empty)++] = 0; last = -1; l_num_empty = *num_empty; d = div (start, 8); data = ((uint8_t*)maskPR->line[scanline])+d.quot; for (x = start; x < end;) { endx = end; if (type == IgnoreBounds && (endx > x1 || x < x2)) { for (; x < endx; x++) { if (*data & (1<<d.rem)) if (x >= x1 && x < x2) val = -1; else val = 1; else val = -1; _image_bitmap_next_bit(d, data); if (last != val) empty_segs[l_num_empty++] = x; last = val; } } else { for (; x < endx; x++) { if (*data & (1<<d.rem)) val = 1; else val = -1; _image_bitmap_next_bit(d, data); if (last != val) empty_segs[l_num_empty++] = x; last = val; } } } *num_empty = l_num_empty; if (last > 0) empty_segs[(*num_empty)++] = x; empty_segs[(*num_empty)++] = G_MAXINT; }
// ============================================================================================ void TestLauncher::run() { bool res = false; int bsize = audioDeviceSettings->getBufferSize(); unsigned int deviceChan = audioDeviceSettings->getOutputChannels(); int nbuff; int remsamples; double progressMax; releaseAudioData(); for (int i = 0; i<stimCount; i++) { if (threadShouldExit()) break; /* Create input stream for the audio file */ File af(getCurrentTest()->soundFiles[i]); wavReader = audioFormatManager.createReaderFor( af ); dbgOut( L"Loading file " + af.getFullPathName() ); if (wavReader == NULL) { lastError = L"Unable to create reader for " + getCurrentTest()->soundFiles[i]; return ; } /* get length and number of channels */ if (wavReader->numChannels > deviceChan) { lastError = L"The number of audio channels in stimuli files exceeds available device outputs."; return ; } chanCount = wavReader->numChannels; samplesCount = static_cast<unsigned int> ( wavReader->lengthInSamples ); /* adjust to the integer number of audio buffers */ nbuff = div(samplesCount,bsize).quot; remsamples = div(samplesCount,bsize).rem; if (remsamples > 0) { samplesCount = bsize*(nbuff+1); progressMax = stimCount*(nbuff+1); } else { progressMax = stimCount*nbuff; } /* create audio data buffers */ currentData = new int* [chanCount]; if (currentData == NULL) { lastError = L"Unable to allocate " + String(2*chanCount*sizeof(float*) + L"b of memory." ); return ; } /* create an array of pointers to data buffers */ for (int ch = 0; ch < chanCount; ch++) { currentData[ch] = new int[samplesCount]; if (currentData[ch] == NULL) { lastError = L"Unable to allocate " + String(samplesCount*sizeof(float*) + L"b of memory." ); /* clean up (data is massive) */ for (int k = 0; k<ch; k++) { delete [] currentData[k]; } delete [] currentData; releaseAudioData(); return ; } /* clear memory */ //zeromem(currentData[ch], sizeof(int)*samplesCount); } /* add array to audioStimData */ audioStimData.add(currentData); /* read file in memory */ for (int k=0; k<nbuff; k++) { res = wavReader->readSamples( currentData, chanCount, bsize*k, bsize*k, bsize); if (!res) { releaseAudioData(); lastError = L"Unable to read data from file " + getCurrentTest()->soundFiles[i]; return ; } /* update progress bar */ setProgress((i*nbuff + k)/progressMax); } /* read the last buffer and zero pad */ if (remsamples > 0) { /* zero-padding is done by AudioFormatReader */ res = wavReader->readSamples( currentData, chanCount, bsize*nbuff, bsize*nbuff, bsize); if (!res) { releaseAudioData(); lastError = L"Unable to read data from file " + getCurrentTest()->soundFiles[i]; return ; } } /* clean up */ delete wavReader; } /*for (int k = 0; k<chanCount; k++) { debugBuffer(getAudioData(0,k,48000), bsize*5, L"audio") + String(k)); }*/ setProgress(1.0); wait(500); }
//------------------------------------------------------------------------------ // const Rmatrix operator/(const Rmatrix &m) const //------------------------------------------------------------------------------ Rmatrix Rmatrix::operator/( const Rmatrix &m) const { #ifdef DEBUG_DIVIDE MessageInterface::ShowMessage (wxT("Rmatrix::operator/() entered this=%s, m=%s\n"), this->ToString().c_str(), m.ToString().c_str()); #endif if ((isSizedD == false) || (m.IsSized() == false)) throw TableTemplateExceptions::UnsizedTable(); bool oneByOneDivideMatrix = false; bool matrixDivideOneByOne = false; #ifdef DEBUG_DIVIDE MessageInterface::ShowMessage (wxT(" rowsD=%d, colsD=%d, m.rowsD=%d, m.colsD=%d\n"), rowsD, colsD, m.rowsD, m.colsD); #endif if (rowsD == 1 && colsD == 1) oneByOneDivideMatrix = true; else if (m.rowsD == 1 && m.colsD == 1) matrixDivideOneByOne = true; #ifdef DEBUG_DIVIDE MessageInterface::ShowMessage (wxT(" oneByOneDivideMatrix=%d, matrixDivideOneByOne=%d\n"), oneByOneDivideMatrix, matrixDivideOneByOne); #endif if (oneByOneDivideMatrix) { Rmatrix div(m.rowsD, m.colsD); Real oneByOne = GetElement(0, 0); for (int i = 0; i < m.rowsD; i++) for (int j = 0; j < m.colsD; j++) div(i, j) = oneByOne / m.GetElement(i, j); #ifdef DEBUG_DIVIDE MessageInterface::ShowMessage (wxT("Rmatrix::operator/() returning OneByOne/Matrix %s\n"), div.ToString().c_str()); #endif return div; } else if (matrixDivideOneByOne) { Rmatrix div(rowsD, colsD); Real oneByOne = m.GetElement(0, 0); for (int i = 0; i < rowsD; i++) for (int j = 0; j < colsD; j++) div(i, j) = GetElement(i, j) / oneByOne; #ifdef DEBUG_DIVIDE MessageInterface::ShowMessage (wxT("Rmatrix::operator/() returning Matrix/OneByOne %s\n"), div.ToString().c_str()); #endif return div; } else return (*this)*m.Inverse(); }
static int dom_decomp_2d(const int Nx, const int Ny, const int Np, int *pNGx, int *pNGy){ int rx, ry, I, rxs, rx_min, rx_max; int rx0=1, ry0=1, I0=0, init=1; div_t dv; /* Compute the ideal decomposition, truncated to an integer, which minimizes the amount of communication. */ rxs = (int)sqrt((double)(Nx*Np)/(double)(Ny > 2*nghost ? Ny - 2*nghost : 1)); /* Constrain the decomposition */ rx_max = Nx < Np ? Nx : Np; /* Require ry >= 1 and rx <= Nx */ if(Ny < Np){ /* Require rx >= 1 and ry <= Ny */ dv = div(Np, Ny); /* rx_min = the smallest integer >= Np/Ny */ rx_min = dv.quot + (dv.rem > 0 ? 1 : 0); } else rx_min = 1; /* printf("rx_min = %d, rx_max = %d\n",rx_min, rx_max); */ /* Constrain rxs to fall in this domain */ rxs = rxs > rx_min ? rxs : rx_min; rxs = rxs < rx_max ? rxs : rx_max; /* Search down for a factor of Np */ for(rx=rxs; rx>=rx_min; rx--){ dv = div(Np,rx); if(dv.rem == 0){ rx0 = rx; ry0 = dv.quot; I0 = (rx0 - 1)*Ny + (ry0 - 1)*(Nx + 2*nghost*rx0); init = 0; break; } } /* Search up for a factor of Np */ for(rx=rxs+1; rx<=rx_max; rx++){ dv = div(Np,rx); if(dv.rem == 0){ ry = dv.quot; I = (rx - 1)*Ny + (ry - 1)*(Nx + 2*nghost*rx); if(init || I < I0){ rx0 = rx; ry0 = ry; I0 = I; init = 0; } break; } } if(init) return 1; /* Error locating a solution */ /* printf("Minimum messaging decomposition has: rx = %d, ry = %d, I = %d\n", rx0, ry0, I0); */ *pNGx = rx0; *pNGy = ry0; return 0; }
font_t* bbutil_load_font(const char* path, int point_size, int dpi) { FT_Library library; FT_Face face; int c; int i, j; font_t* font; if (!initialized) { fprintf(stderr, "EGL has not been initialized\n"); return NULL; } if (!path){ fprintf(stderr, "Invalid path to font file\n"); return NULL; } if(FT_Init_FreeType(&library)) { fprintf(stderr, "Error loading Freetype library\n"); return NULL; } if (FT_New_Face(library, path,0,&face)) { fprintf(stderr, "Error loading font %s\n", path); return NULL; } if(FT_Set_Char_Size ( face, point_size * 64, point_size * 64, dpi, dpi)) { fprintf(stderr, "Error initializing character parameters\n"); return NULL; } font = (font_t*) malloc(sizeof(font_t)); font->initialized = 0; glGenTextures(1, &(font->font_texture)); //Let each glyph reside in 32x32 section of the font texture int segment_size_x = 0, segment_size_y = 0; int num_segments_x = 16; int num_segments_y = 8; FT_GlyphSlot slot; FT_Bitmap bmp; int glyph_width, glyph_height; //First calculate the max width and height of a character in a passed font for(c = 0; c < 128; c++) { if(FT_Load_Char(face, c, FT_LOAD_RENDER)) { fprintf(stderr, "FT_Load_Char failed\n"); free(font); return NULL; } slot = face->glyph; bmp = slot->bitmap; //glyph_width = nextp2(bmp.width); //glyph_height = nextp2(bmp.rows); glyph_width = bmp.width; glyph_height = bmp.rows; if (glyph_width > segment_size_x) { segment_size_x = glyph_width; } if (glyph_height > segment_size_y) { segment_size_y = glyph_height; } } int font_tex_width = nextp2(num_segments_x * segment_size_x); int font_tex_height = nextp2(num_segments_y * segment_size_y); int bitmap_offset_x = 0, bitmap_offset_y = 0; GLubyte* font_texture_data = (GLubyte*) malloc(sizeof(GLubyte) * 2 * font_tex_width * font_tex_height); memset((void*)font_texture_data, 0, sizeof(GLubyte) * 2 * font_tex_width * font_tex_height); if (!font_texture_data) { fprintf(stderr, "Failed to allocate memory for font texture\n"); free(font); return NULL; } // Fill font texture bitmap with individual bmp data and record appropriate size, texture coordinates and offsets for every glyph for(c = 0; c < 128; c++) { if(FT_Load_Char(face, c, FT_LOAD_RENDER)) { fprintf(stderr, "FT_Load_Char failed\n"); free(font); return NULL; } slot = face->glyph; bmp = slot->bitmap; glyph_width = nextp2(bmp.width); glyph_height = nextp2(bmp.rows); div_t temp = div(c, num_segments_x); bitmap_offset_x = segment_size_x * temp.rem; bitmap_offset_y = segment_size_y * temp.quot; for (j = 0; j < glyph_height; j++) { for (i = 0; i < glyph_width; i++) { font_texture_data[2 * ((bitmap_offset_x + i) + (j + bitmap_offset_y) * font_tex_width) + 0] = font_texture_data[2 * ((bitmap_offset_x + i) + (j + bitmap_offset_y) * font_tex_width) + 1] = (i >= bmp.width || j >= bmp.rows)? 0 : bmp.buffer[i + bmp.width * j]; } } font->advance[c] = (float)(slot->advance.x >> 6); font->tex_x1[c] = (float)bitmap_offset_x / (float) font_tex_width; font->tex_x2[c] = (float)(bitmap_offset_x + bmp.width) / (float)font_tex_width; font->tex_y1[c] = (float)bitmap_offset_y / (float) font_tex_height; font->tex_y2[c] = (float)(bitmap_offset_y + bmp.rows) / (float)font_tex_height; font->width[c] = bmp.width; font->height[c] = bmp.rows; font->offset_x[c] = (float)slot->bitmap_left; font->offset_y[c] = (float)((slot->metrics.horiBearingY-face->glyph->metrics.height) >> 6); } glBindTexture(GL_TEXTURE_2D, font->font_texture); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, font_tex_width, font_tex_height, 0, GL_LUMINANCE_ALPHA , GL_UNSIGNED_BYTE, font_texture_data); int err = glGetError(); free(font_texture_data); FT_Done_Face(face); FT_Done_FreeType(library); if (err != 0) { fprintf(stderr, "GL Error 0x%x", err); free(font); return NULL; } font->initialized = 1; return font; }
BigInt operator / (int number) { return div(number); }
void init_mesh(MeshS *pM) { int nblock,num_domains,nd,nl,level,maxlevel=0,nd_this_level; int nDim,nDim_test,dim; int *next_domainid; char block[80]; int ncd,ir,irefine,l,m,n,roffset; int i,Nx[3],izones; div_t xdiv[3]; /* divisor with quot and rem members */ Real root_xmin[3], root_xmax[3]; /* min/max of x in each dir on root grid */ int Nproc_Comm_world=1,nproc=0,next_procID; SideS D1,D2; DomainS *pD, *pCD; #ifdef MPI_PARALLEL int ierr,child_found,groupn,Nranks,Nranks0,max_rank,irank,*ranks; MPI_Group world_group; /* Get total # of processes, in MPI_COMM_WORLD */ ierr = MPI_Comm_size(MPI_COMM_WORLD, &Nproc_Comm_world); #endif /* Start by initializing some quantaties in Mesh structure */ pM->time = 0.0; pM->nstep = 0; pM->outfilename = par_gets("job","problem_id"); /*--- Step 1: Figure out how many levels and domains there are. --------------*/ /* read levels of each domain block in input file and calculate max level */ num_domains = par_geti("job","num_domains"); #ifndef STATIC_MESH_REFINEMENT if (num_domains > 1) ath_error("[init_mesh]: num_domains=%d; for num_domains > 1 configure with --enable-smr\n",num_domains); #endif for (nblock=1; nblock<=num_domains; nblock++){ sprintf(block,"domain%d",nblock); if (par_exist(block,"level") == 0) ath_error("[init_mesh]: level does not exist in block %s\n",block); level = par_geti(block,"level"); maxlevel = MAX(maxlevel,level); } /* set number of levels in Mesh, and allocate DomainsPerLevel array */ pM->NLevels = maxlevel + 1; /* level counting starts at 0 */ pM->DomainsPerLevel = (int*)calloc_1d_array(pM->NLevels,sizeof(int)); if (pM->DomainsPerLevel == NULL) ath_error("[init_mesh]: malloc returned a NULL pointer\n"); /* Now figure out how many domains there are at each level */ for (nl=0; nl<=maxlevel; nl++){ nd_this_level=0; for (nblock=1; nblock<=num_domains; nblock++){ sprintf(block,"domain%d",nblock); if (par_geti(block,"level") == nl) nd_this_level++; } /* Error if there are any levels with no domains. Else set DomainsPerLevel */ if (nd_this_level == 0) { ath_error("[init_mesh]: Level %d has zero domains\n",nl); } else { pM->DomainsPerLevel[nl] = nd_this_level; } } /*--- Step 2: Set up root level. --------------------------------------------*/ /* Find the <domain> block in the input file corresponding to the root level, * and set root level properties in Mesh structure */ if (pM->DomainsPerLevel[0] != 1) ath_error("[init_mesh]: Level 0 has %d domains\n",pM->DomainsPerLevel[0]); for (nblock=1; nblock<=num_domains; nblock++){ sprintf(block,"domain%d",nblock); level = par_geti(block,"level"); if (level == 0){ root_xmin[0] = par_getd(block,"x1min"); root_xmax[0] = par_getd(block,"x1max"); root_xmin[1] = par_getd(block,"x2min"); root_xmax[1] = par_getd(block,"x2max"); root_xmin[2] = par_getd(block,"x3min"); root_xmax[2] = par_getd(block,"x3max"); Nx[0] = par_geti(block,"Nx1"); Nx[1] = par_geti(block,"Nx2"); Nx[2] = par_geti(block,"Nx3"); /* number of dimensions of root level, to test against all other inputs */ nDim=0; for (i=0; i<3; i++) if (Nx[i]>1) nDim++; if (nDim==0) ath_error("[init_mesh] None of Nx1,Nx2,Nx3 > 1\n"); /* some error tests of root grid */ for (i=0; i<3; i++) { if (Nx[i] < 1) { ath_error("[init_mesh]: Nx%d in %s must be >= 1\n",(i+1),block); } if(root_xmax[i] < root_xmin[i]) { ath_error("[init_mesh]: x%dmax < x%dmin in %s\n",(i+1),block); } } if (nDim==1 && Nx[0]==1) { ath_error("[init_mesh]:1D requires Nx1>1: in %s Nx1=1,Nx2=%d,Nx3=%d\n", block,Nx[1],Nx[2]); } if (nDim==2 && Nx[2]>1) {ath_error( "[init_mesh]:2D requires Nx1,Nx2>1: in %s Nx1=%d,Nx2=%d,Nx3=%d\n", block,Nx[0],Nx[1],Nx[2]); } /* Now that everything is OK, set root grid properties in Mesh structure */ for (i=0; i<3; i++) { pM->Nx[i] = Nx[i]; pM->RootMinX[i] = root_xmin[i]; pM->RootMaxX[i] = root_xmax[i]; pM->dx[i] = (root_xmax[i] - root_xmin[i])/(Real)(Nx[i]); } /* Set BC flags on root domain */ pM->BCFlag_ix1 = par_geti_def(block,"bc_ix1",0); pM->BCFlag_ix2 = par_geti_def(block,"bc_ix2",0); pM->BCFlag_ix3 = par_geti_def(block,"bc_ix3",0); pM->BCFlag_ox1 = par_geti_def(block,"bc_ox1",0); pM->BCFlag_ox2 = par_geti_def(block,"bc_ox2",0); pM->BCFlag_ox3 = par_geti_def(block,"bc_ox3",0); } } /*--- Step 3: Allocate and initialize domain array. --------------------------*/ /* Allocate memory and set pointers for Domain array in Mesh. Since the * number of domains nd depends on the level nl, this is a strange array * because it is not [nl]x[nd]. Rather it is nl pointers to nd[nl] Domains. * Compare to the calloc_2d_array() function in ath_array.c */ if((pM->Domain = (DomainS**)calloc((maxlevel+1),sizeof(DomainS*))) == NULL){ ath_error("[init_mesh] failed to allocate memory for %d Domain pointers\n", (maxlevel+1)); } if((pM->Domain[0]=(DomainS*)calloc(num_domains,sizeof(DomainS))) == NULL){ ath_error("[init_mesh] failed to allocate memory for Domains\n"); } for(nl=1; nl<=maxlevel; nl++) pM->Domain[nl] = (DomainS*)((unsigned char *)pM->Domain[nl-1] + pM->DomainsPerLevel[nl-1]*sizeof(DomainS)); /* Loop over every <domain> block in the input file, and initialize each Domain * in the mesh hierarchy (the Domain array), including the root level Domain */ next_domainid = (int*)calloc_1d_array(pM->NLevels,sizeof(int)); for(nl=0; nl<=maxlevel; nl++) next_domainid[nl] = 0; for (nblock=1; nblock<=num_domains; nblock++){ sprintf(block,"domain%d",nblock); /* choose nd coordinate in Domain array for this <domain> block according * to the order it appears in input */ nl = par_geti(block,"level"); if (next_domainid[nl] > (pM->DomainsPerLevel[nl])-1) ath_error("[init_mesh]: Exceeded available domain ids on level %d\n",nl); nd = next_domainid[nl]; next_domainid[nl]++; irefine = 1; for (ir=1;ir<=nl;ir++) irefine *= 2; /* C pow fn only takes doubles !! */ /* Initialize level, number, input <domain> block number, and total number of * cells in this Domain */ pM->Domain[nl][nd].Level = nl; pM->Domain[nl][nd].DomNumber = nd; pM->Domain[nl][nd].InputBlock = nblock; pM->Domain[nl][nd].Nx[0] = par_geti(block,"Nx1"); pM->Domain[nl][nd].Nx[1] = par_geti(block,"Nx2"); pM->Domain[nl][nd].Nx[2] = par_geti(block,"Nx3"); /* error tests: dimensions of domain */ nDim_test=0; for (i=0; i<3; i++) if (pM->Domain[nl][nd].Nx[i]>1) nDim_test++; if (nDim_test != nDim) { ath_error("[init_mesh]: in %s grid is %dD, but in root level it is %dD\n", block,nDim_test,nDim); } for (i=0; i<3; i++) { if (pM->Domain[nl][nd].Nx[i] < 1) { ath_error("[init_mesh]: %s/Nx%d = %d must be >= 1\n", block,(i+1),pM->Domain[nl][nd].Nx[i]); } } if (nDim==1 && pM->Domain[nl][nd].Nx[0]==1) {ath_error( "[init_mesh]: 1D requires Nx1>1 but in %s Nx1=1,Nx2=%d,Nx3=%d\n", block,pM->Domain[nl][nd].Nx[1],pM->Domain[nl][nd].Nx[2]); } if (nDim==2 && pM->Domain[nl][nd].Nx[2]>1) {ath_error( "[init_mesh]:2D requires Nx1,Nx2 > 1 but in %s Nx1=%d,Nx2=%d,Nx3=%d\n", block,pM->Domain[nl][nd].Nx[0],pM->Domain[nl][nd].Nx[1], pM->Domain[nl][nd].Nx[2]); } for (i=0; i<nDim; i++) { xdiv[i] = div(pM->Domain[nl][nd].Nx[i], irefine); if (xdiv[i].rem != 0){ ath_error("[init_mesh]: %s/Nx%d = %d must be divisible by %d\n", block,(i+1),pM->Domain[nl][nd].Nx[i],irefine); } } /* Set cell size based on level of domain, but only if Ncell > 1 */ for (i=0; i<3; i++) { if (pM->Domain[nl][nd].Nx[i] > 1) { pM->Domain[nl][nd].dx[i] = pM->dx[i]/(Real)(irefine); } else { pM->Domain[nl][nd].dx[i] = pM->dx[i]; } } /* Set displacement of Domain from origin. By definition, root level has 0 * displacement, so only read for levels other than root */ for (i=0; i<3; i++) pM->Domain[nl][nd].Disp[i] = 0; if (nl != 0) { if (par_exist(block,"iDisp") == 0) ath_error("[init_mesh]: iDisp does not exist in block %s\n",block); pM->Domain[nl][nd].Disp[0] = par_geti(block,"iDisp"); /* jDisp=0 if problem is only 1D */ if (pM->Nx[1] > 1) { if (par_exist(block,"jDisp") == 0) ath_error("[init_mesh]: jDisp does not exist in block %s\n",block); pM->Domain[nl][nd].Disp[1] = par_geti(block,"jDisp"); } /* kDisp=0 if problem is only 2D */ if (pM->Nx[2] > 1) { if (par_exist(block,"kDisp") == 0) ath_error("[init_mesh]: kDisp does not exist in block %s\n",block); pM->Domain[nl][nd].Disp[2] = par_geti(block,"kDisp"); } } for (i=0; i<nDim; i++) { xdiv[i] = div(pM->Domain[nl][nd].Disp[i], irefine); if (xdiv[i].rem != 0){ ath_error("[init_mesh]: %s/Disp%d = %d must be divisible by %d\n", block,(i+1),pM->Domain[nl][nd].Disp[i],irefine); } } /* Use cell size and displacement from origin to compute min/max of x1/x2/x3 on * this domain. Ensure that if Domain touches root grid boundary, the min/max * of this Domain are set IDENTICAL to values in root grid */ for (i=0; i<3; i++){ if (pM->Domain[nl][nd].Disp[i] == 0) { pM->Domain[nl][nd].MinX[i] = root_xmin[i]; } else { pM->Domain[nl][nd].MinX[i] = root_xmin[i] + ((Real)(pM->Domain[nl][nd].Disp[i]))*pM->Domain[nl][nd].dx[i]; } izones= (pM->Domain[nl][nd].Disp[i] + pM->Domain[nl][nd].Nx[i])/irefine; if(izones == pM->Nx[i]){ pM->Domain[nl][nd].MaxX[i] = root_xmax[i]; } else { pM->Domain[nl][nd].MaxX[i] = pM->Domain[nl][nd].MinX[i] + ((Real)(pM->Domain[nl][nd].Nx[i]))*pM->Domain[nl][nd].dx[i]; } pM->Domain[nl][nd].RootMinX[i] = root_xmin[i]; pM->Domain[nl][nd].RootMaxX[i] = root_xmax[i]; } } /*---------- end loop over domain blocks in input file ------------------*/ /*--- Step 4: Check that domains on the same level are non-overlapping. ------*/ /* Compare the integer coordinates of the sides of Domains at the same level. * Print error if Domains overlap or touch. */ for (nl=maxlevel; nl>0; nl--){ /* start at highest level, and skip root */ for (nd=0; nd<(pM->DomainsPerLevel[nl])-1; nd++){ for (i=0; i<3; i++) { D1.ijkl[i] = pM->Domain[nl][nd].Disp[i]; D1.ijkr[i] = pM->Domain[nl][nd].Disp[i] + pM->Domain[nl][nd].Nx[i]; } for (ncd=nd+1; ncd<(pM->DomainsPerLevel[nl]); ncd++) { for (i=0; i<3; i++) { D2.ijkl[i] = pM->Domain[nl][ncd].Disp[i]; D2.ijkr[i] = pM->Domain[nl][ncd].Disp[i] + pM->Domain[nl][ncd].Nx[i]; } if (D1.ijkl[0] <= D2.ijkr[0] && D1.ijkr[0] >= D2.ijkl[0] && D1.ijkl[1] <= D2.ijkr[1] && D1.ijkr[1] >= D2.ijkl[1] && D1.ijkl[2] <= D2.ijkr[2] && D1.ijkr[2] >= D2.ijkl[2]){ ath_error("Domains %d and %d at same level overlap or touch\n", pM->Domain[nl][nd].InputBlock,pM->Domain[nl][ncd].InputBlock); } } }} /*--- Step 5: Check for illegal geometry of child/parent Domains -------------*/ for (nl=0; nl<maxlevel; nl++){ for (nd=0; nd<pM->DomainsPerLevel[nl]; nd++){ pD = (DomainS*)&(pM->Domain[nl][nd]); /* set ptr to this Domain */ for (i=0; i<3; i++) { D1.ijkl[i] = pD->Disp[i]; D1.ijkr[i] = pD->Disp[i] + pD->Nx[i]; } for (ncd=0; ncd<pM->DomainsPerLevel[nl+1]; ncd++){ pCD = (DomainS*)&(pM->Domain[nl+1][ncd]); /* set ptr to potential child*/ for (i=0; i<3; i++) { D2.ijkl[i] = pCD->Disp[i]/2; D2.ijkr[i] = 1; if (pCD->Nx[i] > 1) D2.ijkr[i] = (pCD->Disp[i] + pCD->Nx[i])/2; } if (D1.ijkl[0] <= D2.ijkr[0] && D1.ijkr[0] >= D2.ijkl[0] && D1.ijkl[1] <= D2.ijkr[1] && D1.ijkr[1] >= D2.ijkl[1] && D1.ijkl[2] <= D2.ijkr[2] && D1.ijkr[2] >= D2.ijkl[2]){ /* check for child Domains that touch edge of parent (and are not at edges of * root), extends past edge of parent, or are < nghost/2 from edge of parent */ for (dim=0; dim<nDim; dim++){ irefine = 1; for (i=1;i<=nl;i++) irefine *= 2; /* parent refinement lev */ roffset = (pCD->Disp[dim] + pCD->Nx[dim])/(2*irefine) - pM->Nx[dim]; if (((D2.ijkl[dim] == D1.ijkl[dim]) && (pD->Disp[dim] != 0)) || ((D2.ijkr[dim] == D1.ijkr[dim]) && (roffset != 0))) { for (i=0; i<nDim; i++) { D1.ijkl[i] /= irefine; /* report indices scaled to root */ D1.ijkr[i] /= irefine; D2.ijkl[i] /= irefine; D2.ijkr[i] /= irefine; } ath_error("[init_mesh] child Domain D%d[is,ie,js,je,ks,ke]=[%d %d %d %d %d %d] touches parent D%d[is,ie,js,je,ks,ke]=[%d %d %d %d %d %d]\n", pCD->InputBlock,D2.ijkl[0],D2.ijkr[0],D2.ijkl[1],D2.ijkr[1], D2.ijkl[2],D2.ijkr[2],pD->InputBlock,D1.ijkl[0],D1.ijkr[0], D1.ijkl[1],D1.ijkr[1],D1.ijkl[2],D1.ijkr[2]); } if ((D2.ijkl[dim] < D1.ijkl[dim]) || (D2.ijkr[dim] > D1.ijkr[dim])) { for (i=0; i<nDim; i++) { D1.ijkl[i] /= irefine; /* report indices scaled to root */ D1.ijkr[i] /= irefine; D2.ijkl[i] /= irefine; D2.ijkr[i] /= irefine; } ath_error("[init_mesh] child Domain D%d[is,ie,js,je,ks,ke]=[%d %d %d %d %d %d] extends past parent D%d[is,ie,js,je,ks,ke]=[%d %d %d %d %d %d]\n", pCD->InputBlock,D2.ijkl[0],D2.ijkr[0],D2.ijkl[1],D2.ijkr[1], D2.ijkl[2],D2.ijkr[2],pD->InputBlock,D1.ijkl[0],D1.ijkr[0], D1.ijkl[1],D1.ijkr[1],D1.ijkl[2],D1.ijkr[2]); } if (((2*(D2.ijkl[dim]-D1.ijkl[dim]) < nghost) && (2*(D2.ijkl[dim]-D1.ijkl[dim]) > 0 )) || ((2*(D1.ijkr[dim]-D2.ijkr[dim]) < nghost) && (2*(D1.ijkr[dim]-D2.ijkr[dim]) > 0 ))) { for (i=0; i<nDim; i++) { D1.ijkl[i] /= irefine; /* report indices scaled to root */ D1.ijkr[i] /= irefine; D2.ijkl[i] /= irefine; D2.ijkr[i] /= irefine; } ath_error("[init_mesh] child Domain D%d[is,ie,js,je,ks,ke]=[%d %d %d %d %d %d] closer than nghost/2 to parent D%d[is,ie,js,je,ks,ke]=[%d %d %d %d %d %d]\n", pCD->InputBlock,D2.ijkl[0],D2.ijkr[0],D2.ijkl[1],D2.ijkr[1], D2.ijkl[2],D2.ijkr[2],pD->InputBlock,D1.ijkl[0],D1.ijkr[0], D1.ijkl[1],D1.ijkr[1],D1.ijkl[2],D1.ijkr[2]); } } } } }} /*--- Step 6: Divide each Domain into Grids, and allocate to processor(s) ---*/ /* Get the number of Grids in each direction. These are given either in the * <domain?> block in the input file, or by automatic decomposition given the * number of processor desired for this domain. */ next_procID = 0; /* start assigning processors to Grids at ID=0 */ for (nl=0; nl<=maxlevel; nl++){ for (nd=0; nd<(pM->DomainsPerLevel[nl]); nd++){ pD = (DomainS*)&(pM->Domain[nl][nd]); /* set ptr to this Domain */ sprintf(block,"domain%d",pD->InputBlock); #ifndef MPI_PARALLEL for (i=0; i<3; i++) pD->NGrid[i] = 1; #else nproc = par_geti_def(block,"AutoWithNProc",0); /* Read layout of Grids from input file */ if (nproc == 0){ pD->NGrid[0] = par_geti_def(block,"NGrid_x1",1); pD->NGrid[1] = par_geti_def(block,"NGrid_x2",1); pD->NGrid[2] = par_geti_def(block,"NGrid_x3",1); if (pD->NGrid[0] == 0) ath_error("[init_mesh] Cannot enter NGrid_x1=0 in %s\n",block); if (pD->NGrid[1] == 0) ath_error("[init_mesh] Cannot enter NGrid_x2=0 in %s\n",block); if (pD->NGrid[2] == 0) ath_error("[init_mesh] Cannot enter NGrid_x3=0 in %s\n",block); } /* Auto decompose Domain into Grids. To use this option, set "AutoWithNProc" * to number of processors desired for this Domain */ else if (nproc > 0){ if(dom_decomp(pD->Nx[0],pD->Nx[1],pD->Nx[2],nproc, &(pD->NGrid[0]),&(pD->NGrid[1]),&(pD->NGrid[2]))) ath_error("[init_mesh]: Error in automatic Domain decomposition\n"); /* Store the domain decomposition in the par database */ par_seti(block,"NGrid_x1","%d",pD->NGrid[0],"x1 decomp"); par_seti(block,"NGrid_x2","%d",pD->NGrid[1],"x2 decomp"); par_seti(block,"NGrid_x3","%d",pD->NGrid[2],"x3 decomp"); } else { ath_error("[init_mesh] invalid AutoWithNProc=%d in %s\n",nproc,block); } #endif /* MPI_PARALLEL */ /* test for conflicts between number of grids and dimensionality */ for (i=0; i<3; i++){ if(pD->NGrid[i] > 1 && pD->Nx[i] <= 1) ath_error("[init_mesh]: %s/NGrid_x%d = %d and Nx%d = %d\n",block, (i+1),pD->NGrid[i],(i+1),pD->Nx[i]); } /* check there are more processors than Grids needed by this Domain. */ nproc = (pD->NGrid[0])*(pD->NGrid[1])*(pD->NGrid[2]); if(nproc > Nproc_Comm_world) ath_error( "[init_mesh]: %d Grids requested by block %s and only %d procs\n" ,nproc,block,Nproc_Comm_world); /* Build 3D array to store data on Grids in this Domain */ if ((pD->GData = (GridsDataS***)calloc_3d_array(pD->NGrid[2],pD->NGrid[1], pD->NGrid[0],sizeof(GridsDataS))) == NULL) ath_error( "[init_mesh]: GData calloc returned a NULL pointer\n"); /* Divide the domain into blocks */ for (i=0; i<3; i++) { xdiv[i] = div(pD->Nx[i], pD->NGrid[i]); } /* Distribute cells in Domain to Grids. Assign each Grid to a processor ID in * the MPI_COMM_WORLD communicator. For single-processor jobs, there is only * one ID=0, and the GData array will have only one element. */ for(n=0; n<(pD->NGrid[2]); n++){ for(m=0; m<(pD->NGrid[1]); m++){ for(l=0; l<(pD->NGrid[0]); l++){ for (i=0; i<3; i++) pD->GData[n][m][l].Nx[i] = xdiv[i].quot; pD->GData[n][m][l].ID_Comm_world = next_procID++; if (next_procID > ((Nproc_Comm_world)-1)) next_procID=0; }}} /* If the Domain is not evenly divisible put the extra cells on the first * Grids in each direction, maintaining the load balance as much as possible */ for(n=0; n<(pD->NGrid[2]); n++){ for(m=0; m<(pD->NGrid[1]); m++){ for(l=0; l<xdiv[0].rem; l++){ pD->GData[n][m][l].Nx[0]++; } } } xdiv[0].rem=0; for(n=0; n<(pD->NGrid[2]); n++){ for(m=0; m<xdiv[1].rem; m++) { for(l=0; l<(pD->NGrid[0]); l++){ pD->GData[n][m][l].Nx[1]++; } } } xdiv[1].rem=0; for(n=0; n<xdiv[2].rem; n++){ for(m=0; m<(pD->NGrid[1]); m++){ for(l=0; l<(pD->NGrid[0]); l++){ pD->GData[n][m][l].Nx[2]++; } } } xdiv[2].rem=0; /* Initialize displacements from origin for each Grid */ for(n=0; n<(pD->NGrid[2]); n++){ for(m=0; m<(pD->NGrid[1]); m++){ pD->GData[n][m][0].Disp[0] = pD->Disp[0]; for(l=1; l<(pD->NGrid[0]); l++){ pD->GData[n][m][l].Disp[0] = pD->GData[n][m][l-1].Disp[0] + pD->GData[n][m][l-1].Nx[0]; } } } for(n=0; n<(pD->NGrid[2]); n++){ for(l=0; l<(pD->NGrid[0]); l++){ pD->GData[n][0][l].Disp[1] = pD->Disp[1]; for(m=1; m<(pD->NGrid[1]); m++){ pD->GData[n][m][l].Disp[1] = pD->GData[n][m-1][l].Disp[1] + pD->GData[n][m-1][l].Nx[1]; } } } for(m=0; m<(pD->NGrid[1]); m++){ for(l=0; l<(pD->NGrid[0]); l++){ pD->GData[0][m][l].Disp[2] = pD->Disp[2]; for(n=1; n<(pD->NGrid[2]); n++){ pD->GData[n][m][l].Disp[2] = pD->GData[n-1][m][l].Disp[2] + pD->GData[n-1][m][l].Nx[2]; } } } } /* end loop over ndomains */ } /* end loop over nlevels */ /* check that total number of Grids was partitioned evenly over total number of * MPI processes available (equal to one for single processor jobs) */ if (next_procID != 0) ath_error("[init_mesh]:total # of Grids != total # of MPI procs\n"); /*--- Step 7: Allocate a Grid for each Domain on this processor --------------*/ for (nl=0; nl<=maxlevel; nl++){ for (nd=0; nd<(pM->DomainsPerLevel[nl]); nd++){ pD = (DomainS*)&(pM->Domain[nl][nd]); /* set ptr to this Domain */ sprintf(block,"domain%d",pD->InputBlock); pD->Grid = NULL; /* Loop over GData array, and if there is a Grid assigned to this proc, * allocate it */ for(n=0; n<(pD->NGrid[2]); n++){ for(m=0; m<(pD->NGrid[1]); m++){ for(l=0; l<(pD->NGrid[0]); l++){ if (pD->GData[n][m][l].ID_Comm_world == myID_Comm_world) { if ((pD->Grid = (GridS*)malloc(sizeof(GridS))) == NULL) ath_error("[init_mesh]: Failed to malloc a Grid for %s\n",block); } }}} } } /*--- Step 8: Create an MPI Communicator for each Domain ---------------------*/ #ifdef MPI_PARALLEL /* Allocate memory for ranks[] array */ max_rank = 0; for (nl=0; nl<=maxlevel; nl++){ for (nd=0; nd<(pM->DomainsPerLevel[nl]); nd++){ pD = (DomainS*)&(pM->Domain[nl][nd]); /* set ptr to this Domain */ Nranks = (pD->NGrid[0])*(pD->NGrid[1])*(pD->NGrid[2]); max_rank = MAX(max_rank, Nranks); }} ranks = (int*)calloc_1d_array(max_rank,sizeof(int)); /* Extract handle of group defined by MPI_COMM_WORLD communicator */ ierr = MPI_Comm_group(MPI_COMM_WORLD, &world_group); for (nl=0; nl<=maxlevel; nl++){ for (nd=0; nd<(pM->DomainsPerLevel[nl]); nd++){ pD = (DomainS*)&(pM->Domain[nl][nd]); /* set ptr to this Domain */ /* Load integer array with ranks of processes in MPI_COMM_WORLD updating Grids * on this Domain. The ranks of these processes in the new Comm_Domain * communicator created below are equal to the indices of this array */ Nranks = (pD->NGrid[0])*(pD->NGrid[1])*(pD->NGrid[2]); groupn = 0; for(n=0; n<(pD->NGrid[2]); n++){ for(m=0; m<(pD->NGrid[1]); m++){ for(l=0; l<(pD->NGrid[0]); l++){ ranks[groupn] = pD->GData[n][m][l].ID_Comm_world; pD->GData[n][m][l].ID_Comm_Domain = groupn; groupn++; }}} /* Create a new group for this Domain; use it to create a new communicator */ ierr = MPI_Group_incl(world_group,Nranks,ranks,&(pD->Group_Domain)); ierr = MPI_Comm_create(MPI_COMM_WORLD,pD->Group_Domain,&(pD->Comm_Domain)); }} free_1d_array(ranks); #endif /* MPI_PARALLEL */ /*--- Step 9: Create MPI Communicators for Child and Parent Domains ----------*/ #if defined(MPI_PARALLEL) && defined(STATIC_MESH_REFINEMENT) /* Initialize communicators to NULL, since not all Domains use them, and * allocate memory for ranks[] array */ for (nl=0; nl<=maxlevel; nl++){ for (nd=0; nd<(pM->DomainsPerLevel[nl]); nd++){ pM->Domain[nl][nd].Comm_Parent = MPI_COMM_NULL; pM->Domain[nl][nd].Comm_Children = MPI_COMM_NULL; } } if (maxlevel > 0) { ranks = (int*)calloc_1d_array(Nproc_Comm_world,sizeof(int)); } /* For each Domain up to (maxlevel-1), initialize communicator with children */ for (nl=0; nl<maxlevel; nl++){ for (nd=0; nd<pM->DomainsPerLevel[nl]; nd++){ pD = (DomainS*)&(pM->Domain[nl][nd]); /* set ptr to this Domain */ child_found = 0; /* Load integer array with ranks of processes in MPI_COMM_WORLD updating Grids * on this Domain, in case a child Domain is found. Set IDs in Comm_Children * communicator based on index in rank array, in case child found. If no * child is found these ranks will never be used. */ Nranks = (pD->NGrid[0])*(pD->NGrid[1])*(pD->NGrid[2]); groupn = 0; for(n=0; n<(pD->NGrid[2]); n++){ for(m=0; m<(pD->NGrid[1]); m++){ for(l=0; l<(pD->NGrid[0]); l++){ ranks[groupn] = pD->GData[n][m][l].ID_Comm_world; pD->GData[n][m][l].ID_Comm_Children = groupn; groupn++; }}} /* edges of this Domain */ for (i=0; i<3; i++) { D1.ijkl[i] = pD->Disp[i]; D1.ijkr[i] = pD->Disp[i] + pD->Nx[i]; } /* Loop over all Domains at next level, looking for children of this Domain */ for (ncd=0; ncd<pM->DomainsPerLevel[nl+1]; ncd++){ pCD = (DomainS*)&(pM->Domain[nl+1][ncd]); /* set ptr to potential child*/ /* edges of potential child Domain */ for (i=0; i<3; i++) { D2.ijkl[i] = pCD->Disp[i]/2; D2.ijkr[i] = 1; if (pCD->Nx[i] > 1) D2.ijkr[i] = (pCD->Disp[i] + pCD->Nx[i])/2; } if (D1.ijkl[0] < D2.ijkr[0] && D1.ijkr[0] > D2.ijkl[0] && D1.ijkl[1] < D2.ijkr[1] && D1.ijkr[1] > D2.ijkl[1] && D1.ijkl[2] < D2.ijkr[2] && D1.ijkr[2] > D2.ijkl[2]){ child_found = 1; /* Child found. Add child processors to ranks array, but only if they are * different from processes currently there (including parent and any previously * found children). Set IDs associated with Comm_Parent communicator, since on * the child Domain this is the same as the Comm_Children communicator on the * parent Domain */ for(n=0; n<(pCD->NGrid[2]); n++){ for(m=0; m<(pCD->NGrid[1]); m++){ for(l=0; l<(pCD->NGrid[0]); l++){ irank = -1; for (i=0; i<Nranks; i++) { if(pCD->GData[n][m][l].ID_Comm_world == ranks[i]) irank = i; } if (irank == -1) { ranks[groupn] = pCD->GData[n][m][l].ID_Comm_world; pCD->GData[n][m][l].ID_Comm_Parent = groupn; groupn++; Nranks++; } else { pCD->GData[n][m][l].ID_Comm_Parent = ranks[irank]; } }}} } } /* After looping over all potential child Domains, create a new communicator if * a child was found */ if (child_found == 1) { ierr = MPI_Group_incl(world_group, Nranks, ranks, &(pD->Group_Children)); ierr = MPI_Comm_create(MPI_COMM_WORLD,pD->Group_Children, &pD->Comm_Children); /* Loop over children to set Comm_Parent communicators */ for (ncd=0; ncd<pM->DomainsPerLevel[nl+1]; ncd++){ pCD = (DomainS*)&(pM->Domain[nl+1][ncd]); for (i=0; i<3; i++) { D2.ijkl[i] = pCD->Disp[i]/2; D2.ijkr[i] = 1; if (pCD->Nx[i] > 1) D2.ijkr[i] = (pCD->Disp[i] + pCD->Nx[i])/2; } if (D1.ijkl[0] < D2.ijkr[0] && D1.ijkr[0] > D2.ijkl[0] && D1.ijkl[1] < D2.ijkr[1] && D1.ijkr[1] > D2.ijkl[1] && D1.ijkl[2] < D2.ijkr[2] && D1.ijkr[2] > D2.ijkl[2]){ pCD->Comm_Parent = pD->Comm_Children; } } } }} #endif /* MPI_PARALLEL & STATIC_MESH_REFINEMENT */ free(next_domainid); return; }
void PVector::normalize() { float m = mag(); if (m != 0) { div(m); } }
double_buffer( InfoStruct *recInfo, float *leadSnds[], float *lagSnds[], float *locations, float *azimuths, float *rove, float *scalesLead, float *scalesLag, float *attensLead, int nSignal ) { FILE *fptr; long seekpos = 0; float preloadScale = .2; int i, j; char OutFNA [MAX_FILENAME_LEN]; char OutFNB [MAX_FILENAME_LEN]; float temp; int record = recInfo->record; int cnt = 1; unsigned int DEC_FACT = recInfo->decimateFactor; unsigned int SignalPlayFlag = 0; unsigned int signalScale = 0, Signalcnt = 0, readflag = 0; unsigned int MAX_SIGNAL_JITTER = recInfo->max_signal_jitter; unsigned int NUM_CARRIERS_TO_ROVE = recInfo->num_carriers; unsigned int rove_id; unsigned int TRIALS_TO_SHOW = 3; long NPTS = recInfo->buf_pts; /* just for plotting PDR trace in real time */ long DEC_PTS = ceil(NPTS / pow(2, DEC_FACT)); long ONSET = ceil(recInfo->sound_onset / pow(2, DEC_FACT)); long NPTS_totalplay = recInfo->nptsTotalPlay; long templ; long buffer_cnt=0; float HAB_LOC = recInfo->hab_loc; int src[3]; float sf[3]; div_t div_result; int loc; /* Display output variables: */ int t0,t1, n; float elapsed_time; float rem_time; int min; float sec, cntdown; char str[100] = { '\0' }; float pdrBuffer[DEFAULT_PTS]; int len; float xy[2]; /* select SS1 output */ int ss_id, out_port; srand( (unsigned)time( NULL ) ); /* setup session info display */ len = ceil(NPTS * (SRATE/1E3)); // was commented out - put back in on Sep 14, 2009 if (record) { play0_record0(recInfo->outFN1, recInfo->outFN2); remove(recInfo->outFN1); remove(recInfo->outFN2); //remove(recInfo->AD_FN); } // end comment out if(!S2init(0, INIT_SECONDARY, 20000)) mexErrMsgTxt("S2init failed"); if(!APlock(200, 0)) { S2close(); mexErrMsgTxt("APLock failed"); } if(!XBlock(200, 0)) { APunlock(0); S2close(); mexErrMsgTxt("XBlock failed"); } trash(); dropall(); // set up buffers allot16( PLAY_SPEC, 10); allot16( CHA_SEQ, 10); allot16( BUF_A1, NPTS); allot16( BUF_A2, NPTS); allot16( CHB_SEQ, 10); allot16( BUF_B1, NPTS); allot16( BUF_B2, NPTS); // play specification list dpush(10); value(0); make(0,CHA_SEQ); make(1,CHB_SEQ); make(2,0); qpop16(PLAY_SPEC); // playsequence for ChanA dpush(10); value(0); make(0,BUF_A1); make(1,1); make(2,BUF_A2); make(3,1); make(4,0); qpop16(CHA_SEQ); // playsequence for ChanB dpush(10); value(0); make(0,BUF_B1); make(1,1); make(2,BUF_B2); make(3,1); make(4,0); qpop16(CHB_SEQ); if (record) // record eye signal { // set up buffers allot16( REC_SPEC, 10); allot16( RECCHA_SEQ, 10); allot16( RECBUF_A1, NPTS); allot16( RECBUF_A2, NPTS); allot16( RECCHB_SEQ, 10); allot16( RECBUF_B1, NPTS); allot16( RECBUF_B2, NPTS); temp = ceil(NPTS / pow(2, DEC_FACT)); allot16( DECBUF_A, temp); allot16( DECBUF_B, temp); // record specification list dpush(10); value(0); make(0,RECCHA_SEQ); make(1,RECCHB_SEQ); make(2,0); qpop16(REC_SPEC); // recordsequence for ChanA dpush(10); value(0); make(0,RECBUF_A1); make(1,1); make(2,RECBUF_A2); make(3,1); make(4,0); qpop16(RECCHA_SEQ); // recordsequence for ChanB dpush(10); value(0); make(0,RECBUF_B1); make(1,1); make(2,RECBUF_B2); make(3,1); make(4,0); qpop16(RECCHB_SEQ); } // allot and load buffers for LEAD SOUNDS for( j=0; j<NUM_CARRIERS_TO_ROVE; j++ ) { allotf( BUF_LEAD(j), NPTS); pushf(leadSnds[j], NPTS); qpopf(BUF_LEAD(j)); } // allot and load buffers for LAG SOUNDS for( j=0; j<NUM_CARRIERS_TO_ROVE; j++ ) { allotf( BUF_LAG(j), NPTS); pushf(lagSnds[j], NPTS); qpopf(BUF_LAG(j)); } // setup PD1 PD1clear(1); PD1srate(1,SRATE); PD1npts(1,-1); PD1resetDSP(1,0xFFF); dropall(); PD1clrsched(1); PD1nstrms(1, 2, record*2); PD1addsimp(1, IREG[0], DAC[0]); PD1specIB (1, IB[0], IREG[0]); PD1addsimp(1, IREG[1], DAC[1]); PD1specIB (1, IB[1], IREG[1]); if (record) { PD1specOB (1, OB[1], ADC[1]); PD1specOB (1, OB[0], ADC[0]); } PF1freq(1,12000,0); PF1freq(2,12000,0); dropall(); /* set LED thresholds */ PD1setIO(1,0.01,9.99,0.01,9.99); /* setup signal switchers */ /* SWITCH BETWEEN 8 LAG SPEAKERS (Nos. 2, 3, 4, ... 9) */ /* (NOTE: Speaker #1 is reserved for the lead sound) */ SS1clear(1); /* left SS1 (LAG) */ SS1mode(1, QUAD_2_1); /* inputs 1, 3, 5, 7 => outputs A,B,C,D */ SS1select(1,0,1); /* Default Lag Output is A (Hab Location) */ // set attenuation PA4atten(1,0); /* lead channel */ PA4atten(2,0); /* lag ch */ // ready,set,go!! dropall(); // nothing to chanA (LEAD) dpush(NPTS); value(0); qpop16(BUF_A1); dpush(NPTS); value(0); qpop16(BUF_A2); // nothing to chanB (LAG) dpush(NPTS); value(0); qpop16(BUF_B1); dpush(NPTS); value(0); qpop16(BUF_B2); seqplay(PLAY_SPEC); if (record) seqrecord(REC_SPEC); PD1arm (1); pfireall(); PD1go (1); do { do{}while (playseg(1)==BUF_A1); // wait for #1 buffers to finish t0 = clock(); SignalPlayFlag = 0; if(signalScale >0) { readflag = 1; } else if(readflag) { readflag = 0; SignalPlayFlag = 1; } /* count down to next test trial */ cntdown = (recInfo->ISI - cnt)*(NPTS*SRATE/1E6); for(i=0; i<(recInfo->n_trials - Signalcnt); i++) { if(locations[Signalcnt+i]!=HAB_LOC) break; cntdown += (recInfo->ISI+1)*(NPTS*SRATE/1E6); } /* display session info */ elapsed_time = seekpos*(SRATE/1E6); div_result = div( elapsed_time, 60 ); min = div_result.quot; sec = elapsed_time - (60*min); memset(str,'\0',sizeof(str)); n=sprintf(str,"session.elapsed_time(1)=%i; session.elapsed_time(2)=%.3f;",min,sec); mexEvalString(str); rem_time = NPTS_totalplay*(SRATE/1E6) - elapsed_time; div_result = div( rem_time, 60 ); min = div_result.quot; sec = rem_time - (60*min); memset(str,'\0',sizeof(str)); n=sprintf(str,"session.rem_time(1)=%i; session.rem_time(2)=%.3f;",min,sec); mexEvalString(str); div_result = div( cntdown, 60 ); min = div_result.quot; sec = cntdown - (60*min); memset(str,'\0',sizeof(str)); n=sprintf(str,"session.next_test_trial(1)=%i; session.next_test_trial(2)=%.3f;",min,sec); mexEvalString(str); mexEvalString("sessionPlots('Update Session Info');"); // re-loading #1 playbuffers // LEAD to chanA LAG to chanB dropall(); if (cnt==recInfo->ISI) { // Jitter trial presentation if (MAX_SIGNAL_JITTER > 0) { cnt = ( rand() % (2*MAX_SIGNAL_JITTER+1) ) - MAX_SIGNAL_JITTER; // gives a range of +/- MAX_SIGNAL_JITTER } else { cnt = 0; } loc = locations[Signalcnt]; /* location series indicates lag speaker # (2, 3, 4, ... 9) */ // set attenuation PA4atten(1,attensLead[loc-2]); /* lead channel */ PA4atten(2,0); /* lag ch */ SS1clear(1); SS1clear(2); if (loc < 6) { ss_id = 1; /* use left SS1 */ out_port = loc - 2; /* decrement by 2 for output selection */ } else { ss_id = 2; /* use right SS1 */ out_port = loc - 6; /* decrement by 6 for output selection */ } SS1mode(ss_id, QUAD_2_1); /* inputs 1, 3, 5, 7 => outputs A,B,C,D */ SS1select(ss_id,out_port,1); /* Chan B (LAG) location ( speakers A...D = 0...3 ) */ /* plot a marker on trial sequence plot */ memset(str,'\0',sizeof(str)); n=sprintf(str,"session.trialcnt=%i; session.trialval=%10.1f;sessionPlots('Update Trial Plot');",Signalcnt+1,azimuths[loc-1]); mexEvalString(str); rove_id = rove[Signalcnt ++] - 1; /* decrement by 1 for C indexing */ signalScale=scalesLead[loc-2]; qpushf(BUF_LEAD(rove_id)); scale(signalScale); /* always scale with first speaker scaling value */ qpop16(BUF_A1); signalScale=scalesLag[loc-2]; qpushf(BUF_LAG(rove_id)); scale(signalScale); /* decrement by 1 to get appropriate speaker scale value */ qpop16(BUF_B1); } else { signalScale = 0; cnt++; dpush(NPTS); value(0); qpop16(BUF_A1); dpush(NPTS); value(0); qpop16(BUF_B1); } if(record) { // downloading #1 recordbuffers qpush16 (RECBUF_A1); decimate (DEC_FACT); make(0, SignalPlayFlag); make(1, loc); qpop16 (DECBUF_A); dama2disk16 (DECBUF_A, recInfo->outFN1, 1); qpush16 (RECBUF_B1); decimate (DEC_FACT); // plot PDR trace qdup(); popf(pdrBuffer); // store last buffer in matlab variable for plotting for(i=0; i<DEC_PTS; i++) { memset(str,'\0',sizeof(str)); n=sprintf(str,"session.last_buffer(%i+1)= %.5f;",i,pdrBuffer[i]); mexEvalString(str); } if(SignalPlayFlag) { if(locations[Signalcnt-1]==HAB_LOC) { mexEvalString("session.test_flag=1;"); } else { mexEvalString("session.test_flag=Inf;"); } } else { mexEvalString("session.test_flag=0;"); } // tell sessionPlots to update trace mexEvalString("sessionPlots('Update Trace Plot');"); make(0, SignalPlayFlag); make(1, loc); qpop16 (DECBUF_B); dama2disk16 (DECBUF_B, recInfo->outFN2, 1); dropall (); } /* processing time */ t1=clock(); memset(str,'\0',sizeof(str)); n = sprintf(str,"session.proc_time = [session.proc_time %.3f];",((float) (t1-t0))/CLOCKS_PER_SEC); mexEvalString(str); mexEvalString("sessionPlots('Update Session Info');"); seekpos += NPTS; if(seekpos < NPTS_totalplay) { // wait for #2 buffers to finish do{}while (playseg(1)==BUF_A2); // wait for #2 buffers to finish t0=clock(); SignalPlayFlag = 0; if(signalScale >0) { readflag = 1; } else if(readflag) { readflag = 0; SignalPlayFlag = 1; } /* count down to next test trial */ cntdown = (recInfo->ISI - cnt)*(NPTS*SRATE/1E6); for(i=0; i<(recInfo->n_trials - Signalcnt); i++) { if(locations[Signalcnt+i]!=HAB_LOC) break; cntdown += (recInfo->ISI+1)*(NPTS*SRATE/1E6); } /* display session info */ elapsed_time = seekpos*(SRATE/1E6); div_result = div( elapsed_time, 60 ); min = div_result.quot; sec = elapsed_time - (60*min); memset(str,'\0',sizeof(str)); n=sprintf(str,"session.elapsed_time(1)=%i; session.elapsed_time(2)=%.3f;",min,sec); mexEvalString(str); rem_time = NPTS_totalplay*(SRATE/1E6) - elapsed_time; div_result = div( rem_time, 60 ); min = div_result.quot; sec = rem_time - (60*min); memset(str,'\0',sizeof(str)); n=sprintf(str,"session.rem_time(1)=%i; session.rem_time(2)=%.3f;",min,sec); mexEvalString(str); div_result = div( cntdown, 60 ); min = div_result.quot; sec = cntdown - (60*min); memset(str,'\0',sizeof(str)); n=sprintf(str,"session.next_test_trial(1)=%i; session.next_test_trial(2)=%.3f;",min,sec); mexEvalString(str); mexEvalString("sessionPlots('Update Session Info');"); // reload #2 playbuffers LEAD to chanA LAG to chanB dropall(); if (cnt==recInfo->ISI) { if (MAX_SIGNAL_JITTER > 0) { cnt = ( rand() % (2*MAX_SIGNAL_JITTER+1) ) - MAX_SIGNAL_JITTER; // gives a range of +/- MAX_SIGNAL_JITTER } else { cnt = 0; } loc = locations[Signalcnt]; /* location series indicates lag speaker # (2, 3, 4, ... 9) */ // set attenuation PA4atten(1,attensLead[loc-2]); /* lead channel */ PA4atten(2,0); /* lag ch */ SS1clear(1); SS1clear(2); if (loc < 6) { ss_id = 1; /* use left SS1 */ out_port = loc - 2; /* decrement by 2 for output selection */ } else { ss_id = 2; /* use right SS1 */ out_port = loc - 6; /* decrement by 6 for output selection */ } SS1mode(ss_id, QUAD_2_1); /* inputs 1, 3, 5, 7 => outputs A,B,C,D */ SS1select(ss_id,out_port,1); /* Chan B (LAG) location ( speakers A...D = 0...3 ) */ /* plot a marker on trial sequence plot */ memset(str,'\0',sizeof(str)); n=sprintf(str,"session.trialcnt=%i; session.trialval=%10.1f;sessionPlots('Update Trial Plot');",Signalcnt+1,azimuths[loc-1]); mexEvalString(str); rove_id = rove[Signalcnt ++] - 1; /* decrement by 1 for C indexing */ signalScale=scalesLead[loc-2]; qpushf(BUF_LEAD(rove_id)); scale(signalScale); /* always scale with first speaker scaling value */ qpop16(BUF_A2); signalScale=scalesLag[loc-2]; qpushf(BUF_LAG(rove_id)); scale(signalScale); /* decrement by 1 to get appropriate speaker scale value */ qpop16(BUF_B2); } else { signalScale = 0; cnt++; dpush(NPTS); value(0);; qpop16(BUF_A2); dpush(NPTS); value(0); qpop16(BUF_B2); } if (record) { // download #2 recordbuffers qpush16 (RECBUF_A2); decimate (DEC_FACT); make(0,SignalPlayFlag); make(1,loc); qpop16 (DECBUF_A); dama2disk16 (DECBUF_A, recInfo->outFN1, 1); qpush16 (RECBUF_B2); decimate (DEC_FACT); // plot PDR trace qdup(); popf(pdrBuffer); // store last buffer in matlab variable for plotting for(i=0; i<DEC_PTS; i++) { memset(str,'\0',sizeof(str)); n=sprintf(str,"session.last_buffer(%i+1)= %.5f;",i,pdrBuffer[i]); mexEvalString(str); } if(SignalPlayFlag) { if(locations[Signalcnt-1]==HAB_LOC) { mexEvalString("session.test_flag=1;"); } else { mexEvalString("session.test_flag=Inf;"); } } else { mexEvalString("session.test_flag=0;"); } // tell sessionPlots to update trace mexEvalString("sessionPlots('Update Trace Plot');"); make(0,SignalPlayFlag); make(1,loc); qpop16 (DECBUF_B); dama2disk16 (DECBUF_B, recInfo->outFN2, 1); dropall (); } if (playseg(1) !=BUF_A1) { PD1stop(1); mexPrintf("got to %d percent of the way\n",seekpos/NPTS_totalplay); mexErrMsgTxt(" APcard too slow? or outFNs incorrect?"); } /* processing time */ t1=clock(); memset(str,'\0',sizeof(str)); n = sprintf(str,"session.proc_time = [session.proc_time %.3f];",((float) (t1-t0))/CLOCKS_PER_SEC); mexEvalString(str); mexEvalString("sessionPlots('Update Session Info');"); seekpos += NPTS; } if (Signalcnt > nSignal) Signalcnt = 0; } while(seekpos < NPTS_totalplay); do{}while (playseg(1)==BUF_A1); /* wait for last 2 buffers to finish */ do{}while (playseg(1)==BUF_A2); PA4mute(1); PA4mute(2); PD1stop(1); PD1clrIO(1); PD1clear(1); mexEvalString("sessionPlots('Finish Session');"); trash(); dropall(); APunlock(0); XBunlock(0); S2close(); }
int main() { hamming(93); div(12913,234); }
MatLab4::MatLab4(char * file_name , char * param_name , char * time_name ) { int len ; int temp ; int endian ; int mat_size ; int type , size ; int mat_type ; int my_byte_order ; div_t div_result ; int row , column , imaginary ; char * temp_ptr ; bool param_found , time_found ; int max_offset , offset = 0 ; fileName_ = file_name ; TRICK_GET_BYTE_ORDER(my_byte_order) ; if ((fp_ = fopen(file_name , "r")) == 0 ) { std::cerr << "ERROR: Couldn't open \"" << file_name << "\": " << std::strerror(errno) << std::endl; exit(-1) ; } // we use fseek calls to move around so I need to know the max offset of the file fseek( fp_ , 0 , SEEK_END ) ; max_offset = ftell(fp_) ; rewind( fp_ ) ; // get field_num from param_name temp_ptr = rindex(param_name, '[') ; if ( temp_ptr != NULL ) { sscanf(&temp_ptr[1] , "%d" , &y_value_.field_num_ ) ; } else { y_value_.field_num_ = 0 ; } // get field_num from time_name temp_ptr = rindex(param_name, '[') ; if ( temp_ptr != NULL ) { sscanf(&temp_ptr[1] , "%d" , &time_value_.field_num_ ) ; } else { time_value_.field_num_ = 0 ; } param_found = time_found = false ; while ( (!param_found || !time_found) && (offset < max_offset)) { // read the type in fread( &temp , 4 , 1 , fp_ ) ; if ( ! strncmp( (char *)&temp , "MATL" , 4 )) { fclose(fp_) ; return ; } // byte swap it if it looks like we need to if ( temp & 0xFFFF0000 ) { temp = trick_byteswap_int(temp) ; } div_result = div(temp , 1000) ; endian = div_result.quot ; temp = div_result.rem ; switch ( endian ) { case 0: swap_ = ( my_byte_order == TRICK_LITTLE_ENDIAN ) ? 0 : 1 ; break ; case 1: swap_ = ( my_byte_order == TRICK_BIG_ENDIAN ) ? 0 : 1 ; break ; default: fprintf(stderr,"Unknown endianness!\n") ; fclose(fp_) ; return ; break ; } div_result = div( temp , 10 ) ; mat_size = div_result.quot ; mat_type = div_result.rem ; switch ( mat_size ) { case 0: type = TRICK_DOUBLE ; size = 8 ; break ; case 1: type = TRICK_FLOAT ; size = 4 ; break ; case 2: type = TRICK_INTEGER ; size = 4 ; break ; case 3: type = TRICK_SHORT ; size = 2 ; break ; case 4: type = TRICK_UNSIGNED_SHORT ; size = 2 ; break ; case 5: type = TRICK_CHARACTER ; size = 1 ; break ; } if ( mat_type != 0 ) { fprintf(stderr,"Unknown matrix type!\n") ; fclose(fp_) ; return ; } fread( &row , 4 , 1 , fp_ ) ; if ( swap_ ) { row = trick_byteswap_int(row) ; } fread( &column , 4 , 1 , fp_ ) ; if ( swap_ ) { column = trick_byteswap_int(column) ; } fread( &imaginary , 4 , 1 , fp_ ) ; if ( swap_ ) { imaginary = trick_byteswap_int(imaginary) ; } fread( &len , 4 , 1 , fp_ ) ; if ( swap_ ) { len = trick_byteswap_int(len) ; } temp_ptr = new char[len +1] ; fread( temp_ptr , len , 1 , fp_ ) ; if ( ! strncmp( temp_ptr , param_name , len ) && y_value_.field_num_ < column ) { y_value_.size_ = size ; y_value_.type_ = type ; y_value_.rows_ = row ; y_value_.columns_ = column ; y_value_.imaginary_ = imaginary ; y_value_.data_offset_ = ftell(fp_) ; param_found = true ; } if ( ! strncmp( temp_ptr , time_name , len ) && time_value_.field_num_ < column ) { time_value_.size_ = size ; time_value_.type_ = type ; time_value_.rows_ = row ; time_value_.columns_ = column ; time_value_.imaginary_ = imaginary ; time_value_.data_offset_ = ftell(fp_) ; time_found = true ; } delete temp_ptr ; // skip to next parameter fseek( fp_ , row * column * size * ( 1 + imaginary ) , SEEK_CUR ) ; offset = ftell(fp_) ; } curr_row_ = 0 ; }
void cf_configuration::handle_config_cmd(char *cmd, const uint32_t &cmd_hash, char *arg, char *buf, const unsigned long &linenum) { char tmp[BUFFER_SIZE]; int vec_count; char *vec[4]; int port; std::vector<std::string> elts; std::string host, path, address, port_str; switch (cmd_hash) { case hash_domain_name_weight: _domain_name_weight = atof(arg); configuration_spec::html_table_row(_config_args,cmd,arg, "Weight given to the domain names in the simple filter"); break; case hash_record_cache_timeout: _record_cache_timeout = atoi(arg); configuration_spec::html_table_row(_config_args,cmd,arg, "Timeout on cached remote records, in seconds"); break; case hash_cf_peer: strlcpy(tmp,arg,sizeof(tmp)); vec_count = miscutil::ssplit(tmp," \t",vec,SZ(vec),1,1); div_t divresult; divresult = div(vec_count,2); if (divresult.rem != 0) { errlog::log_error(LOG_LEVEL_ERROR,"Wrong number of parameter when specifying static collaborative filtering peer"); break; } address = vec[0]; urlmatch::parse_url_host_and_path(address,host,path); miscutil::tokenize(host,elts,":"); port = -1; if (elts.size()>1) { host = elts.at(0); port = atoi(elts.at(1).c_str()); } port_str = (port != -1) ? ":" + miscutil::to_string(port) : ""; errlog::log_error(LOG_LEVEL_DEBUG,"adding peer %s%s%s with resource %s", host.c_str(),port_str.c_str(),path.c_str(),vec[1]); _pl->add(host,port,path,std::string(vec[1])); configuration_spec::html_table_row(_config_args,cmd,arg, "Remote peer address for collaborative filtering"); break; case hash_dead_peer_check: _dead_peer_check = atoi(arg); configuration_spec::html_table_row(_config_args,cmd,arg, "Interval of time between two dead peer checks"); break; case hash_dead_peer_retries: _dead_peer_retries = atoi(arg); configuration_spec::html_table_row(_config_args,cmd,arg, "Number of retries before marking a peer as dead"); break; case hash_post_url_check: _post_url_check = static_cast<bool>(atoi(arg)); configuration_spec::html_table_row(_config_args,cmd,arg, "Whether to ping and check on posted URLs"); break; case hash_post_radius: _post_radius = static_cast<bool>(atoi(arg)); configuration_spec::html_table_row(_config_args,cmd,arg, "Query similarity impact radius of posted URLs"); break; case hash_post_ua: _post_url_ua = std::string(arg); configuration_spec::html_table_row(_config_args,cmd,arg, "default 'user-agent' header used to retrieve posted URLs"); break; case hash_stop_words_filtering: _stop_words_filtering = static_cast<bool>(atoi(arg)); configuration_spec::html_table_row(_config_args,cmd,arg, "Whether to filter similar queries with stop words"); break; default: break; } }
T boundary(const line<T>& o) const { if (a == o.a) return b > o.b ? inf : -inf; return div(o.b - b, a - o.a); }
void ideinit(void) { memdisk = _binary_fs_img_start; disksize = div(((uint)_binary_fs_img_end - (uint)_binary_fs_img_start), 512); }