int queue_flush(t_conf *conf, t_simple_list *client)
{
t_list *queue;
t_list *free_cell;
queue = client->queue;
if (!(free_cell = queue_find_empty_data_cell(client)))
return (-1);
while ((queue) && (queue->status == RECEIVED))
{
if (!free_cell)
{
MYERROR("Queue design is too small\n");
queue_dump(client);
while (1);
return (-1);
}
queue_prepare_ack(free_cell,queue->info.num_seq);
if (extract_data(conf, client, queue) == -1)
return (-1);
queue = queue->next;
free_cell = free_cell->next;
}
if (queue == client->queue)
return (-1);
return (queue_change_root(client, queue));
}
void exec_cmd(FILE* w, bool first, Disc* d, const string& basename) {
for (auto i=cmds.begin();i!=cmds.end();i++)
{
switch((*i)[0])
{
case 'g':
{
int start_fad = atoi((++i)->c_str());
int size = atoi((++i)->c_str());
extract_data(w, first, d, start_fad, size);
}
break;
case 'i':
extract_info(w, first, d, basename);
break;
case 'h':
printf("hashes not supported yet");
break;
case 'f':
printf("fingerprint not supported yet");
break;
}
}
}
static int do_request(PROGRAMMER * pgm, AVRMEM *m)
{
struct ft245r_request *p;
int addr, bytes, j, n;
char buf[FT245R_FRAGMENT_SIZE+1+128];
if (!req_head) return 0;
p = req_head;
req_head = p->next;
if (!req_head) req_tail = req_head;
addr = p->addr;
bytes = p->bytes;
n = p->n;
memset(p, 0, sizeof(struct ft245r_request));
p->next = req_pool;
req_pool = p;
ft245r_recv(pgm, buf, bytes);
for (j=0; j<n; j++) {
m->buf[addr++] = extract_data(buf , (j * 4 + 3));
}
#if 0
if (n == 0) // paged_write
fprintf(stderr, "recv addr 0x%04x buf size %d \n",addr, bytes);
#endif
return 1;
}
void marathon_dispatcher::dispatch()
{
for (list::iterator it = m_messages.begin(); it != m_messages.end();)
{
extract_data(*it);
it = m_messages.erase(it);
}
}
void fortuna_get_bytes(unsigned len, uint8_t *dst)
{
if (!initDone)
init();
if (!dst || !len)
return;
extract_data(&mainState, len, dst);
}
int main(void)
{
t_data *rooms;
t_env env;
rooms = NULL;
env.room_count = -1;
extract_data(&env, &rooms);
ft_putchar('\n');
lem_in(rooms, &env);
return (0);
}
void
fortuna_get_bytes(unsigned len, uint8 *dst)
{
if (!init_done)
{
init_state(&main_state);
init_done = 1;
}
if (!dst || !len)
return;
extract_data(&main_state, len, dst);
}
/*
* transmit an AVR device command and return the results; 'cmd' and
* 'res' must point to at least a 4 byte data buffer
*/
static int ft245r_cmd(PROGRAMMER * pgm, const unsigned char *cmd,
unsigned char *res) {
int i,buf_pos;
unsigned char buf[128];
buf_pos = 0;
for (i=0; i<4; i++) {
buf_pos += set_data(pgm, buf+buf_pos, cmd[i]);
}
buf[buf_pos] = 0;
buf_pos++;
ft245r_send (pgm, buf, buf_pos);
ft245r_recv (pgm, buf, buf_pos);
res[0] = extract_data(pgm, buf, 0);
res[1] = extract_data(pgm, buf, 1);
res[2] = extract_data(pgm, buf, 2);
res[3] = extract_data(pgm, buf, 3);
return 0;
}
void init_scene(int fd, t_scene *scene)
{
t_header header;
if (!(read(fd, &header, sizeof(header)) == sizeof(header)) ||
!valid_scene(header))
exit(0);
scene->materials = extract_data(fd,
sizeof(t_material) * header.materials_nb);
scene->lights = extract_data(fd, sizeof(t_light) * header.lights_nb);
scene->planes = extract_data(fd, sizeof(t_plane) * header.planes_nb);
scene->spheres = extract_data(fd, sizeof(t_sphere) * header.spheres_nb);
scene->cylinders = extract_data(fd,
sizeof(t_cylinder) * header.cylinders_nb);
scene->cones = extract_data(fd, sizeof(t_cone) * header.cones_nb);
if (!file_ended(fd))
exit(0);
scene->camera_x = header.camera_x;
scene->camera_y = header.camera_y;
scene->camera_z = header.camera_z;
scene->view = header.view;
scene->materials_nb = header.materials_nb;
scene->lights_nb = header.lights_nb;
scene->planes_nb = header.planes_nb;
scene->spheres_nb = header.spheres_nb;
scene->cylinders_nb = header.cylinders_nb;
scene->cones_nb = header.cones_nb;
}
static void handle_oml_measure(uint8_t *data, size_t len, uint8_t *meas_buf,
size_t meas_size, meas_handler_t handler, char *measure_str)
{
struct timeval timestamp;
size_t rlen;
uint32_t t_ref_s;
uint32_t t_us;
uint8_t num_meas = data[1];
uint8_t *data_ptr = &data[2];
// length == (header + time_ref_seconds) + n_measures * (t_us + len)
rlen = 2 + sizeof(uint32_t); // header
rlen += num_meas * (sizeof(uint32_t) + meas_size); // measures
if (len != rlen) {
PRINT_ERROR("Invalid %s pkt len: %zu != expected %zu\n",
measure_str, len, rlen);
return;
}
/*
* Handle payload
*/
// copy basetime for seconds
extract_data((uint8_t *)&t_ref_s, &data_ptr, sizeof(uint32_t));
for (int i = 0; i < num_meas; i++) {
// Time
extract_data((uint8_t *)&t_us, &data_ptr, sizeof(uint32_t));
calculate_time_extended(×tamp, t_ref_s, t_us);
// Measure
extract_data(meas_buf, &data_ptr, meas_size);
handler(meas_buf, ×tamp);
}
}
static int main_work(FILE *inp, FILE *outp)
{
struct bsid sid;
while(!ensure_read(&sid, inp))
{
size_t s=0;
s=(sid.Size)+(sid.dwStreamNameSize);
if(sid.dwStreamId==1)
{
if(extract_data(inp, outp, s)) return 1;
break;
}
else
{
if(skip_data(inp, s)) return -1;
}
}
return 0;
}
/* XML stuff to extract the data we need from the Rubrica file */
static GSList *
extract_cards(xmlNodePtr card)
{
GSList *addrlist = NULL;
while (card) {
if (!xmlStrcmp(card->name, CXMLCHARP("Card"))) {
LibBalsaAddress *address = libbalsa_address_new();
xmlNodePtr children;
address->full_name =
xml_node_get_attr(card, CXMLCHARP("name"));
children = card->children;
while (children) {
if (!xmlStrcmp(children->name, CXMLCHARP("Data")))
extract_data(children->children, &address->first_name,
&address->last_name, &address->nick_name);
else if (!xmlStrcmp(children->name, CXMLCHARP("Work")))
extract_work(children->children,
&address->organization);
else if (!xmlStrcmp(children->name, CXMLCHARP("Net")))
extract_net(children->children,
&address->address_list);
children = children->next;
}
if (address->address_list)
addrlist = g_slist_prepend(addrlist, address);
else
g_object_unref(address);
}
card = card->next;
}
return addrlist;
}
static int
fortuna_bytes(unsigned char *outdata, int size)
{
int ret = 0;
HEIMDAL_MUTEX_lock(&fortuna_mutex);
if (!fortuna_init())
goto out;
resend_bytes += size;
if (resend_bytes > FORTUNA_RESEED_BYTE || resend_bytes < size) {
resend_bytes = 0;
fortuna_reseed();
}
extract_data(&main_state, size, outdata);
ret = 1;
out:
HEIMDAL_MUTEX_unlock(&fortuna_mutex);
return ret;
}
static int do_request(PROGRAMMER * pgm, AVRMEM *m) {
struct ft245r_request *p;
int addr, bytes, j, n;
unsigned char buf[FT245R_FRAGMENT_SIZE+1+128];
if (!req_head) return 0;
p = req_head;
req_head = p->next;
if (!req_head) req_tail = req_head;
addr = p->addr;
bytes = p->bytes;
n = p->n;
memset(p, 0, sizeof(struct ft245r_request));
p->next = req_pool;
req_pool = p;
ft245r_recv(pgm, buf, bytes);
for (j=0; j<n; j++) {
m->buf[addr++] = extract_data(pgm, buf , (j * 4 + 3));
}
return 1;
}
void partition3d::init(std::string const& datafilename,
dimension const& dimx, dimension const& dimy, dimension const& dimz)
{
init_dimension(datafilename, dimension::ye, dimx, "ye", ye_values_);
init_dimension(datafilename, dimension::temp, dimy, "logtemp", logtemp_values_);
init_dimension(datafilename, dimension::rho, dimz, "logrho", logrho_values_);
// Initialize the energy shift.
extract_data(datafilename, "energy_shift", &energy_shift_, 0, 1);
// Read our slice of data.
std::size_t array_size = dim_[dimension::ye].count_ *
dim_[dimension::temp].count_ * dim_[dimension::rho].count_;
init_data(datafilename, "logpress", logpress_values_, array_size);
init_data(datafilename, "logenergy", logenergy_values_, array_size);
init_data(datafilename, "entropy", entropy_values_, array_size);
init_data(datafilename, "munu", munu_values_, array_size);
init_data(datafilename, "cs2", cs2_values_, array_size);
init_data(datafilename, "dedt", dedt_values_, array_size);
init_data(datafilename, "dpdrhoe", dpdrhoe_values_, array_size);
init_data(datafilename, "dpderho", dpderho_values_, array_size);
#if SHENEOS_SUPPORT_FULL_API
init_data(datafilename, "muhat", muhat_values_, array_size);
init_data(datafilename, "mu_e", mu_e_values_, array_size);
init_data(datafilename, "mu_p", mu_p_values_, array_size);
init_data(datafilename, "mu_n", mu_n_values_, array_size);
init_data(datafilename, "Xa", xa_values_, array_size);
init_data(datafilename, "Xh", xh_values_, array_size);
init_data(datafilename, "Xp", xp_values_, array_size);
init_data(datafilename, "Xn", xn_values_, array_size);
init_data(datafilename, "Abar", abar_values_, array_size);
init_data(datafilename, "Zbar", zbar_values_, array_size);
init_data(datafilename, "gamma", gamma_values_, array_size);
#endif
}
void partition::init(std::string datafilename, dimension const& dim,
std::size_t num_nodes)
{
// store all parameters
dim_ = dim;
// account for necessary overlap
std::size_t ghost_width_left = 0, ghost_width_right = 0;
if (dim_.offset_ + dim_.count_ < dim_.size_-1)
++ghost_width_right;
if (dim_.offset_ > 0)
++ghost_width_left;
// extract the full data range
extract_data_range(datafilename, min_value_, max_value_, delta_,
dim_.offset_, dim_.offset_+dim_.count_);
// read the slice of our data
values_.reset(new double[dim_.count_ + ghost_width_left + ghost_width_right]);
extract_data(datafilename, values_.get(),
dim_.offset_ - ghost_width_left,
dim_.count_ + ghost_width_left + ghost_width_right);
}
int main(int argc, char *argv[])
{
int c;
if (install_allegro(SYSTEM_NONE, &errno, atexit) != 0)
return 1;
for (c=1; c<argc; c++) {
if (argv[c][0] == '-') {
switch (utolower(argv[c][1])) {
case 'a':
opt_allegro = TRUE;
break;
case 'b':
opt_binary = TRUE;
break;
case 'c':
opt_compress = TRUE;
break;
case 'd':
opt_delete = TRUE;
break;
case 'x':
opt_extract = TRUE;
break;
case '0':
if ((opt_password) || (c >= argc-1)) {
usage();
return 1;
}
opt_password = argv[++c];
break;
default:
printf("Unknown option '%s'\n", argv[c]);
return 1;
}
}
else {
if (!opt_filename)
opt_filename = argv[c];
else if (!opt_dataname)
opt_dataname = argv[c];
else {
usage();
return 1;
}
}
}
if ((!opt_filename) ||
((opt_allegro) && (opt_binary)) ||
((opt_delete) && (opt_extract))) {
usage();
return 1;
}
if (opt_password)
packfile_password(opt_password);
if (opt_delete) {
if (opt_dataname) {
usage();
return 1;
}
update_file(opt_filename, NULL);
}
else if (opt_extract) {
if (!opt_dataname) {
usage();
return 1;
}
if ((!opt_allegro) && (!opt_binary)) {
printf("The -x option must be used together with -a or -b\n");
return 1;
}
extract_data();
}
else {
if (opt_dataname)
update_file(opt_filename, opt_dataname);
else
show_stats();
}
return err;
}
static void
mode_in(struct cpio *cpio)
{
struct archive *a;
struct archive_entry *entry;
struct archive *ext;
const char *destpath;
int r;
ext = archive_write_disk_new();
if (ext == NULL)
lafe_errc(1, 0, "Couldn't allocate restore object");
r = archive_write_disk_set_options(ext, cpio->extract_flags);
if (r != ARCHIVE_OK)
lafe_errc(1, 0, "%s", archive_error_string(ext));
a = archive_read_new();
if (a == NULL)
lafe_errc(1, 0, "Couldn't allocate archive object");
archive_read_support_compression_all(a);
archive_read_support_format_all(a);
if (archive_read_open_file(a, cpio->filename, cpio->bytes_per_block))
lafe_errc(1, archive_errno(a),
"%s", archive_error_string(a));
for (;;) {
r = archive_read_next_header(a, &entry);
if (r == ARCHIVE_EOF)
break;
if (r != ARCHIVE_OK) {
lafe_errc(1, archive_errno(a),
"%s", archive_error_string(a));
}
if (lafe_excluded(cpio->matching, archive_entry_pathname(entry)))
continue;
if (cpio->option_rename) {
destpath = cpio_rename(archive_entry_pathname(entry));
archive_entry_set_pathname(entry, destpath);
} else
destpath = archive_entry_pathname(entry);
if (destpath == NULL)
continue;
if (cpio->verbose)
fprintf(stdout, "%s\n", destpath);
if (cpio->uid_override >= 0)
archive_entry_set_uid(entry, cpio->uid_override);
if (cpio->gid_override >= 0)
archive_entry_set_gid(entry, cpio->gid_override);
r = archive_write_header(ext, entry);
if (r != ARCHIVE_OK) {
fprintf(stderr, "%s: %s\n",
archive_entry_pathname(entry),
archive_error_string(ext));
} else if (archive_entry_size(entry) > 0) {
r = extract_data(a, ext);
if (r != ARCHIVE_OK)
cpio->return_value = 1;
}
}
r = archive_read_close(a);
if (r != ARCHIVE_OK)
lafe_errc(1, 0, "%s", archive_error_string(a));
r = archive_write_close(ext);
if (r != ARCHIVE_OK)
lafe_errc(1, 0, "%s", archive_error_string(ext));
if (!cpio->quiet) {
int64_t blocks = (archive_position_uncompressed(a) + 511)
/ 512;
fprintf(stderr, "%lu %s\n", (unsigned long)blocks,
blocks == 1 ? "block" : "blocks");
}
archive_read_finish(a);
archive_write_finish(ext);
exit(cpio->return_value);
}
/* Insert a request in the backend */
static void apm_driver_mysql_insert_request(TSRMLS_D)
{
APM_DEBUG("[MySQL driver] ======apm_driver_mysql_insert_request \n");
char *application_esc = NULL, *script_esc = NULL, *uri_esc = NULL, *host_esc = NULL, *cookies_esc = NULL, *post_vars_esc = NULL, *referer_esc = NULL, *method_esc = NULL, *status_esc = NULL, *sql = NULL;
unsigned int application_len = 0, script_len = 0, uri_len = 0, host_len = 0, ip_int = 0, cookies_len = 0, post_vars_len = 0, referer_len = 0, method_len = 0, status_len = 0;
struct in_addr ip_addr;
MYSQL *connection;
extract_data();
APM_DEBUG("[MySQL driver] Begin insert request\n");
if (APM_G(mysql_is_request_created)) {
APM_DEBUG("[MySQL driver] SKIPPED, request already created.\n");
return;
}
MYSQL_INSTANCE_INIT
if (APM_G(application_id)) {
application_len = strlen(APM_G(application_id));
application_esc = emalloc(application_len * 2 + 1);
application_len = mysql_real_escape_string(connection, application_esc, APM_G(application_id), application_len);
}
APM_MYSQL_ESCAPE_STR(script);
APM_MYSQL_ESCAPE_STR(uri);
APM_MYSQL_ESCAPE_STR(host);
APM_MYSQL_ESCAPE_STR(referer);
APM_MYSQL_ESCAPE_STR(method);
APM_MYSQL_ESCAPE_STR(status);
APM_MYSQL_ESCAPE_SMART_STR(cookies);
APM_MYSQL_ESCAPE_SMART_STR(post_vars);
if (APM_RD(ip_found) && (inet_pton(AF_INET, APM_RD_STRVAL(ip), &ip_addr) == 1)) {
ip_int = ntohl(ip_addr.s_addr);
}
sql = emalloc(166 + application_len + script_len + uri_len + host_len + cookies_len + post_vars_len + referer_len + method_len);
sprintf(
sql,
"INSERT INTO request (application, script, uri, host, ip, cookies, post_vars, referer, method, status) VALUES ('%s', '%s', '%s', '%s', %u, '%s', '%s', '%s', '%s', '%s')",
application_esc ? application_esc : "",
APM_RD(script_found) ? script_esc : "",
APM_RD(uri_found) ? uri_esc : "",
APM_RD(host_found) ? host_esc : "",
ip_int, APM_RD(cookies_found) ? cookies_esc : "",
APM_RD(post_vars_found) ? post_vars_esc : "",
APM_RD(referer_found) ? referer_esc : "",
APM_RD(method_found) ? method_esc : "",
APM_RD(status_found) ? status_esc : "");
APM_DEBUG("[MySQL driver] Sending: %s\n", sql);
if (mysql_query(connection, sql) != 0)
APM_DEBUG("[MySQL driver] Error: %s\n", mysql_error(APM_G(mysql_event_db)));
mysql_query(connection, "SET @request_id = LAST_INSERT_ID()");
efree(sql);
if (application_esc)
efree(application_esc);
if (script_esc)
efree(script_esc);
if (uri_esc)
efree(uri_esc);
if (host_esc)
efree(host_esc);
if (cookies_esc)
efree(cookies_esc);
if (post_vars_esc)
efree(post_vars_esc);
if (referer_esc)
efree(referer_esc);
if (method_esc)
efree(method_esc);
if (status_esc)
efree(status_esc);
APM_G(mysql_is_request_created) = 1;
APM_DEBUG("[MySQL driver] End insert request\n");
}
void Listfiles::get_lineduration(void){
card.openFile(card.filename, true);
//memset(comandline, '\0', sizeof(char)*65 );
//memset(comandline2, '\0', sizeof(char)*65 );
dias=-1, horas=-1, minutos=-1;
char serial_char='\0';
//comandline="";
int posi = 0;
int linecomepoint=0;
simplify3D=-1;
int exit = 0;
while(linecomepoint < 5 && !card.isEndFile()){
memset(comandline, '\0', sizeof(comandline) );
while(comandline[0]!=';' && !card.isEndFile()){
serial_char='\0';
posi = 0;
while(serial_char != '\n' && posi < 49 && !card.isEndFile()){
int16_t n=card.get();
serial_char = (char)n;
comandline[posi]=serial_char;
posi++;
}
exit++;
if(exit>20){
linecomepoint = 5;
}
}
if(linecomepoint == 0){
if (extract_data_Symplify() !=-1 ){
linecomepoint = 5;
simplify3D = 1;
//Serial.println("Simplify");
}
else{
simplify3D = 0;
//Serial.println("CURA");
}
}else{
extract_data();
if (minutos !=-1 ){
linecomepoint = 5;
//Serial.println("Simplify");
}
}
linecomepoint++;
}
Serial.println(simplify3D);
if(simplify3D == 0){
//Serial.println("CURA-1");
//extract_data();
memset(comandline, '\0', sizeof(comandline) );
posi = 0;
serial_char='\0';
while(serial_char != '\n' && posi < 49 && !card.isEndFile()){
int16_t n=card.get();
serial_char = (char)n;
comandline[posi]=serial_char;
posi++;
}
extract_data1();
card.closefile();
memset(comandline, '\0', sizeof(comandline) );
}
else if (simplify3D == 1){
//Serial.println("Simplify-1");
card.sdfinalline();
memset(comandline, '\0', sizeof(comandline) );
linecomepoint=0;
while(linecomepoint < 2 && !card.isEndFile()){
memset(comandline, '\0', sizeof(comandline) );
while(comandline[0]!=';' && !card.isEndFile()){
serial_char='\0';
posi = 0;
while(serial_char != '\n' && posi < 49 && !card.isEndFile()){
int16_t n=card.get();
serial_char = (char)n;
comandline[posi]=serial_char;
posi++;
}
//Serial.println(comandline);
}
//Serial.println(comandline);
linecomepoint++;
}
extract_data();
memset(comandline, '\0', sizeof(comandline) );
posi = 0;
serial_char='\0';
linecomepoint = 0;
while(linecomepoint < 3 && !card.isEndFile()){
memset(comandline, '\0', sizeof(comandline) );
while(comandline[0]!=';' && !card.isEndFile()){
serial_char='\0';
posi = 0;
while(serial_char != '\n' && posi < 49 && !card.isEndFile()){
int16_t n=card.get();
serial_char = (char)n;
comandline[posi]=serial_char;
posi++;
}
//Serial.println(comandline);
}
linecomepoint++;
}
extract_data1();
card.closefile();
memset(comandline, '\0', sizeof(comandline) );
}
}
/*
type :
as define function TM_WRS_MAIL, TRAFFIC_CONTROL_MAIL, etc.
path :
attachment file or some information in file, if no file, path will be NULL
*/
static
void am_send_mail(int type, char *path)
{
FILE *fp;
char title[64], smtp_auth_pass[256];
char date[30];
time_t now;
int status = 0;
memset(title, 0, sizeof(title));
memset(date, 0, sizeof(date));
memset(smtp_auth_pass, 0, sizeof(smtp_auth_pass));
// get current date
time(&now);
StampToDate(now, date);
// email server conf setting
mkdir_if_none("/etc/email");
if((fp = fopen(MAIL_CONF, "w")) == NULL){
_dprintf("fail to open %s\n", MAIL_CONF);
return;
}
#ifdef RTCONFIG_HTTPS
strncpy(smtp_auth_pass,pwdec(nvram_get("PM_SMTP_AUTH_PASS")),256);
#else
strncpy(smtp_auth_pass,nvram_get("PM_SMTP_AUTH_PASS"),256);
#endif
fprintf(fp,"SMTP_SERVER = '%s'\n", nvram_safe_get("PM_SMTP_SERVER"));
fprintf(fp,"SMTP_PORT = '%s'\n", nvram_safe_get("PM_SMTP_PORT"));
fprintf(fp,"MY_NAME = 'Administrator'\n");
fprintf(fp,"MY_EMAIL = '%s'\n", nvram_safe_get("PM_MY_EMAIL"));
fprintf(fp,"USE_TLS = 'true'\n");
fprintf(fp,"SMTP_AUTH = 'LOGIN'\n");
fprintf(fp,"SMTP_AUTH_USER = '******'\n", nvram_safe_get("PM_SMTP_AUTH_USER"));
fprintf(fp,"SMTP_AUTH_PASS = '******'\n", smtp_auth_pass);
fclose(fp);
// mail title
#ifdef RTCONFIG_BWDPI
if(type == TM_WRS_MAIL)
sprintf(title, "AiProtection alert! %s", date);
#endif
#ifdef RTCONFIG_TRAFFIC_CONTROL
if(type == TRAFFIC_CONTROL_MAIL)
sprintf(title, "Traffic control alert! %s", date);
#endif
// create command (attachment or not)
char cmd[512];
memset(cmd, 0, sizeof(cmd));
if (path != NULL){
sprintf(cmd, "email -V -s \"%s\" %s -a \"%s\"", title, nvram_safe_get("PM_MY_EMAIL"), path);
}
else{
sprintf(cmd, "email -V -s \"%s\" %s", title, nvram_safe_get("PM_MY_EMAIL"));
}
// create popen
if((fp = popen(cmd, "w")) == NULL){
_dprintf("%s : popen() error\n", __FUNCTION__);
return;
}
// email content use popen (pipe open) ...
// write mail content
#ifdef RTCONFIG_BWDPI
if(type == TM_WRS_MAIL)
{
// extract mail log into seperated event information
extract_data(path, fp);
fprintf(fp, "Suggest action: Your client devices has been detected suspicious networking behavior and blocked connection with destination server to protect your sensitive information.\nBased on our recommendation, you can\n");
fprintf(fp, "1. Remove app that access this site and don't visit this website to prevent any personal information leak.\n");
fprintf(fp, "2. Check your router security setting.\n");
fprintf(fp, "3. Update security patch for your client or new firmware for your router.\n");
fprintf(fp, "Please refer to attached log file for detail information. You also can link to trend micro website to download security trial software for your client device protection.\n");
fprintf(fp, "\n");
fprintf(fp, "http://www.trendmicro.com/\n");
logmessage("alert mail", "AiProtection send mail");
}
#endif
#ifdef RTCONFIG_TRAFFIC_CONTROL
if(type == TRAFFIC_CONTROL_MAIL)
{
int count = nvram_get_int("traffic_control_count");
fprintf(fp, "Dear user,\n\n");
fprintf(fp, "Traffic Control configuration as below:\n\n");
if((count & 1) == 1){
fprintf(fp, "\t<Primary WAN>\n");
fprintf(fp, "\tRouter Current Traffic: %.2f GB\n", atof(nvram_safe_get("traffic_control_realtime_0")));
fprintf(fp, "\tAlert Traffic: %.2f GB\n", atof(nvram_safe_get("traffic_control_alert_max")));
fprintf(fp, "\tMAX Traffic: %.2f GB\n\n", atof(nvram_safe_get("traffic_control_limit_max")));
}
if((count & 2) == 2){
fprintf(fp, "\t<Secondary WAN>\n");
fprintf(fp, "\tRouter Current Traffic: %.2f GB\n", atof(nvram_safe_get("traffic_control_realtime_1")));
fprintf(fp, "\tAlert Traffic: %.2f GB\n", atof(nvram_safe_get("traffic_control_alert_max")));
fprintf(fp, "\tMAX Traffic: %.2f GB\n\n", atof(nvram_safe_get("traffic_control_limit_max")));
}
fprintf(fp, "Your internet traffic usage have reached the alert vlaue. If you are in limited traffic usage, please get more attention.\n\n");
fprintf(fp, "Thanks,\n");
fprintf(fp, "ASUSTeK Computer Inc.\n");
logmessage("alert mail", "Traffic control send mail");
}
#endif
status = pclose(fp);
if(status == -1) _dprintf("%s : errno %d (%s)\n", __FUNCTION__, errno, strerror(errno));
}
static value_ptr extract_object(bplist_info_ptr bplist, uint64_t objectRef)
{
uint64_t offset;
value_ptr result = NULL;
uint8_t objectTag;
if (objectRef >= bplist->object_count) {
// Out-of-range object reference.
bplist_log("Bad binary plist: object index is out of range.\n");
return NULL;
}
// Use cached object if it exists
result = cache_lookup(bplist->cache, objectRef);
if (result != NULL) return result;
// Otherwise, find object in file.
offset = read_offset(bplist, objectRef);
if (offset > bplist->length) {
// Out-of-range offset.
bplist_log("Bad binary plist: object outside container.\n");
return NULL;
}
objectTag = *(bplist->data_bytes + offset);
switch (objectTag & 0xF0) {
case kTAG_SIMPLE:
result = extract_simple(bplist, offset);
break;
case kTAG_INT:
result = extract_int(bplist, offset);
break;
case kTAG_REAL:
result = extract_real(bplist, offset);
break;
case kTAG_DATE:
result = extract_date(bplist, offset);
break;
case kTAG_DATA:
result = extract_data(bplist, offset);
break;
case kTAG_ASCIISTRING:
result = extract_ascii_string(bplist, offset);
break;
case kTAG_UNICODESTRING:
result = extract_unicode_string(bplist, offset);
break;
case kTAG_UID:
result = extract_uid(bplist, offset);
break;
case kTAG_ARRAY:
result = extract_array(bplist, offset);
break;
case kTAG_DICTIONARY:
result = extract_dictionary(bplist, offset);
break;
default:
// Unknown tag.
bplist_log("Bad binary plist: unknown tag 0x%X.\n",
(objectTag & 0x0F) >> 4);
result = NULL;
}
// Cache and return result.
if (result != NULL)
cache_insert(&bplist->cache, objectRef, result);
return result;
}