static gchar * relative_time_string(nstime_t *timer, int tsprecision, capture_info *cf_info, gboolean want_seconds) { const gchar *second = want_seconds ? " second" : ""; const gchar *plural = want_seconds ? "s" : ""; static gchar time_string_buf[4+1+2+1+2+1+2+1+2+1+2+1+1]; if (cf_info->times_known && cf_info->packet_count > 0) { switch (tsprecision) { case WTAP_TSPREC_SEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%lu%s%s", (unsigned long)timer->secs, second, timer->secs == 1 ? "" : plural); break; case WTAP_TSPREC_DSEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%lu.%01d%s%s", (unsigned long)timer->secs, timer->nsecs / 100000000, second, (timer->secs == 1 && timer->nsecs == 0) ? "" : plural); break; case WTAP_TSPREC_CSEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%lu.%02d%s%s", (unsigned long)timer->secs, timer->nsecs / 10000000, second, (timer->secs == 1 && timer->nsecs == 0) ? "" : plural); break; case WTAP_TSPREC_MSEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%lu.%03d%s%s", (unsigned long)timer->secs, timer->nsecs / 1000000, second, (timer->secs == 1 && timer->nsecs == 0) ? "" : plural); break; case WTAP_TSPREC_USEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%lu.%06d%s%s", (unsigned long)timer->secs, timer->nsecs / 1000, second, (timer->secs == 1 && timer->nsecs == 0) ? "" : plural); break; case WTAP_TSPREC_NSEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%lu.%09d%s%s", (unsigned long)timer->secs, timer->nsecs, second, (timer->secs == 1 && timer->nsecs == 0) ? "" : plural); break; default: g_snprintf(time_string_buf, sizeof time_string_buf, "Unknown precision %d", tsprecision); break; } return time_string_buf; } g_snprintf(time_string_buf, sizeof time_string_buf, "n/a"); return time_string_buf; }
static int get_dirlist (CalcHandle* handle, GNode** vars, GNode** apps) { uint16_t aids[] = { AID_VAR_SIZE, AID_VAR_TYPE, AID_ARCHIVED, }; const int size = sizeof(aids) / sizeof(uint16_t); TreeInfo *ti; int err; CalcAttr **attr; GNode *folder, *root; char fldname[40], varname[40]; char *utf8; (*apps) = g_node_new(NULL); ti = (TreeInfo *)g_malloc(sizeof(TreeInfo)); ti->model = handle->model; ti->type = APP_NODE_NAME; (*apps)->data = ti; (*vars) = g_node_new(NULL); ti = (TreeInfo *)g_malloc(sizeof(TreeInfo)); ti->model = handle->model; ti->type = VAR_NODE_NAME; (*vars)->data = ti; folder = g_node_new(NULL); g_node_append(*vars, folder); root = g_node_new(NULL); g_node_append(*apps, root); // Add permanent variables (Window, RclWindow, TblSet aka WINDW, ZSTO, TABLE) { GNode *node; VarEntry *ve; ve = tifiles_ve_create(); strcpy(ve->name, "Window"); ve->type = TI84p_WINDW; node = g_node_new(ve); g_node_append(folder, node); ve = tifiles_ve_create(); strcpy(ve->name, "RclWin"); ve->type = TI84p_ZSTO; node = g_node_new(ve); g_node_append(folder, node); ve = tifiles_ve_create(); strcpy(ve->name, "TblSet"); ve->type = TI84p_TABLE; node = g_node_new(ve); g_node_append(folder, node); } TRYF(cmd_s_dirlist_request(handle, size, aids)); do { VarEntry *ve = tifiles_ve_create(); GNode *node; attr = ca_new_array(size); err = cmd_r_var_header(handle, fldname, varname, attr); if (err == ERR_EOT) break; else if (err != 0) return err; strcpy(ve->name, varname); ve->size = GINT32_FROM_BE(*((uint32_t *)(attr[0]->data))); ve->type = GINT32_FROM_BE(*((uint32_t *)(attr[1]->data))) & 0xff; ve->attr = attr[2]->data[0] ? ATTRB_ARCHIVED : ATTRB_NONE; ca_del_array(size, attr); node = g_node_new(ve); if (ve->type != TI73_APPL) g_node_append(folder, node); else g_node_append(root, node); utf8 = ticonv_varname_to_utf8(handle->model, ve->name, ve->type); g_snprintf(update_->text, sizeof(update_->text), _("Parsing %s"), utf8); g_free(utf8); update_label(); } while(1); return 0; }
static int recv_flash (CalcHandle* handle, FlashContent* content, VarRequest* vr) { uint16_t aids[] = { AID_ARCHIVED, AID_VAR_VERSION }; const int naids = sizeof(aids) / sizeof(uint16_t); CalcAttr **attrs; const int nattrs = 1; char fldname[40], varname[40]; uint8_t *data; char *utf8; int page; uint16_t data_addr = 0x4000; uint16_t data_page = 0; int r, q; utf8 = ticonv_varname_to_utf8(handle->model, vr->name, vr->type); g_snprintf(update_->text, sizeof(update_->text), "%s", utf8); g_free(utf8); update_label(); attrs = ca_new_array(nattrs); attrs[0] = ca_new(AID_VAR_TYPE2, 4); attrs[0]->data[0] = 0xF0; attrs[0]->data[1] = 0x07; attrs[0]->data[2] = 0x00; attrs[0]->data[3] = vr->type; TRYF(cmd_s_var_request(handle, "", vr->name, naids, aids, nattrs, CA(attrs))); ca_del_array(nattrs, attrs); attrs = ca_new_array(naids); TRYF(cmd_r_var_header(handle, fldname, varname, attrs)); TRYF(cmd_r_var_content(handle, NULL, &data)); content->model = handle->model; strcpy(content->name, vr->name); content->data_type = vr->type; content->device_type = DEVICE_TYPE_83P; content->num_pages = 2048; // TI83+ has 512 KB of FLASH max content->pages = tifiles_fp_create_array(content->num_pages); q = vr->size / FLASH_PAGE_SIZE; r = vr->size % FLASH_PAGE_SIZE; update_->cnt2 = 0; update_->max2 = q; for(page = 0; page < q; page++) { FlashPage *fp = content->pages[page] = tifiles_fp_create(); fp->addr = data_addr; fp->page = data_page++; fp->flag = 0x80; fp->size = FLASH_PAGE_SIZE; fp->data = tifiles_fp_alloc_data(FLASH_PAGE_SIZE); memcpy(fp->data, data + FLASH_PAGE_SIZE*page, FLASH_PAGE_SIZE); update_->cnt2 = page; update_->pbar(); } { FlashPage *fp = content->pages[page] = tifiles_fp_create(); fp->addr = data_addr; fp->page = data_page++; fp->flag = 0x80; fp->size = r; fp->data = tifiles_fp_alloc_data(FLASH_PAGE_SIZE); memcpy(fp->data, data + FLASH_PAGE_SIZE*page, r); update_->cnt2 = page; update_->pbar(); } content->num_pages = page+1; g_free(data); ca_del_array(naids, attrs); return 0; }
void atalk_addr_to_str_buf(const struct atalk_ddp_addr *addrp, gchar *buf, int buf_len) { g_snprintf(buf, buf_len, "%u.%u", addrp->net, addrp->node ); }
static void dissect_pgmopts(ptvcursor_t* cursor, packet_info *pinfo, const char *pktname) { proto_item *tf, *ti, *ti_len; proto_tree *opts_tree = NULL; proto_tree *opt_tree = NULL; tvbuff_t *tvb = ptvcursor_tvbuff(cursor); gboolean theend = FALSE; guint16 opts_total_len; guint8 genopts_type; guint8 genopts_len; guint8 opts_type; opts_tree = proto_tree_add_subtree_format(ptvcursor_tree(cursor), tvb, ptvcursor_current_offset(cursor), -1, ett_pgm_opts, &tf, "%s Options", pktname); ptvcursor_set_tree(cursor, opts_tree); opts_type = tvb_get_guint8(tvb, ptvcursor_current_offset(cursor)); ti = ptvcursor_add(cursor, hf_pgm_opt_type, 1, ENC_BIG_ENDIAN); if (opts_type != PGM_OPT_LENGTH) { expert_add_info_format(pinfo, ti, &ei_pgm_opt_type, "%s Options - initial option is %s, should be %s", pktname, val_to_str(opts_type, opt_vals, "Unknown (0x%02x)"), val_to_str(PGM_OPT_LENGTH, opt_vals, "Unknown (0x%02x)")); return; } ptvcursor_add(cursor, hf_pgm_opt_len, 1, ENC_BIG_ENDIAN); opts_total_len = tvb_get_ntohs(tvb, ptvcursor_current_offset(cursor)); proto_item_append_text(tf, " (Total Length %d)", opts_total_len); proto_item_set_len(tf, opts_total_len); ti_len = ptvcursor_add(cursor, hf_pgm_opt_tlen, 2, ENC_BIG_ENDIAN); if (opts_total_len < 4) { expert_add_info_format(pinfo, ti_len, &ei_pgm_opt_tlen, "%s Options (Total Length %u - invalid, must be >= 4)", pktname, opts_total_len); return; } for (opts_total_len -= 4; !theend && opts_total_len != 0;){ if (opts_total_len < 4) { expert_add_info_format(pinfo, ti_len, &ei_pgm_opt_tlen, "Remaining total options length doesn't have enough for an options header"); break; } genopts_type = tvb_get_guint8(tvb, ptvcursor_current_offset(cursor)); genopts_len = tvb_get_guint8(tvb, ptvcursor_current_offset(cursor)+1); if (genopts_type & PGM_OPT_END) { genopts_type &= ~PGM_OPT_END; theend = TRUE; } switch(genopts_type) { case PGM_OPT_JOIN:{ TLV_CHECK(ett_pgm_opts_join); ptvcursor_set_tree(cursor, opt_tree); ptvcursor_add_no_advance(cursor, hf_pgm_genopt_end, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_type, 1, ENC_BIG_ENDIAN); if (genopts_len < PGM_OPT_JOIN_SIZE) { proto_tree_add_uint_format_value(opt_tree, hf_pgm_genopt_len, tvb, ptvcursor_current_offset(cursor), 1, genopts_len, "%u (bogus, must be >= %u)", genopts_len, PGM_OPT_JOIN_SIZE); break; } ptvcursor_add(cursor, hf_pgm_genopt_len, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_opx, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_join_res, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_join_minjoin, 4, ENC_BIG_ENDIAN); break; } case PGM_OPT_PARITY_PRM:{ guint8 optdata_po; TLV_CHECK(ett_pgm_opts_parityprm); ptvcursor_set_tree(cursor, opt_tree); ptvcursor_add_no_advance(cursor, hf_pgm_genopt_end, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_type, 1, ENC_BIG_ENDIAN); if (genopts_len < PGM_OPT_PARITY_PRM_SIZE) { proto_tree_add_uint_format_value(opt_tree, hf_pgm_genopt_len, ptvcursor_tvbuff(cursor), ptvcursor_current_offset(cursor), 1, genopts_len, "%u (bogus, must be >= %u)", genopts_len, PGM_OPT_PARITY_PRM_SIZE); break; } ptvcursor_add(cursor, hf_pgm_genopt_len, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_opx, 1, ENC_BIG_ENDIAN); optdata_po = tvb_get_guint8(tvb, ptvcursor_current_offset(cursor)); proto_tree_add_uint_format_value(opt_tree, hf_pgm_opt_parity_prm_po, tvb, ptvcursor_current_offset(cursor), 1, optdata_po, "%s (0x%x)", paritystr(optdata_po), optdata_po); ptvcursor_advance(cursor, 1); ptvcursor_add(cursor, hf_pgm_opt_parity_prm_prmtgsz, 4, ENC_BIG_ENDIAN); break; } case PGM_OPT_PARITY_GRP:{ TLV_CHECK(ett_pgm_opts_paritygrp); ptvcursor_set_tree(cursor, opt_tree); ptvcursor_add_no_advance(cursor, hf_pgm_genopt_end, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_type, 1, ENC_BIG_ENDIAN); if (genopts_len < PGM_OPT_PARITY_GRP_SIZE) { proto_tree_add_uint_format_value(opt_tree, hf_pgm_genopt_len, tvb, ptvcursor_current_offset(cursor), 1, genopts_len, "%u (bogus, must be >= %u)", genopts_len, PGM_OPT_PARITY_GRP_SIZE); break; } ptvcursor_add(cursor, hf_pgm_genopt_len, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_opx, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_parity_grp_res, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_parity_grp_prmgrp, 4, ENC_BIG_ENDIAN); break; } case PGM_OPT_NAK_LIST:{ guint8 optdata_len; guint32 naklist[PGM_MAX_NAK_LIST_SZ+1]; unsigned char *nakbuf; gboolean firsttime; int i, j, naks, soffset; TLV_CHECK(ett_pgm_opts_naklist); ptvcursor_set_tree(cursor, opt_tree); ptvcursor_add_no_advance(cursor, hf_pgm_genopt_end, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_type, 1, ENC_BIG_ENDIAN); optdata_len = tvb_get_guint8(tvb, ptvcursor_current_offset(cursor)); ptvcursor_add(cursor, hf_pgm_genopt_len, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_opx, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_nak_res, 1, ENC_BIG_ENDIAN); optdata_len -= PGM_OPT_NAK_LIST_SIZE; tvb_memcpy(tvb, (guint8 *)naklist, ptvcursor_current_offset(cursor), optdata_len); firsttime = TRUE; soffset = 0; naks = (int)(optdata_len/sizeof(guint32)); nakbuf = (unsigned char *)wmem_alloc(wmem_packet_scope(), 8192); j = 0; /* * Print out 8 per line */ for (i=0; i < naks; i++) { soffset += MIN(8192-soffset, g_snprintf(nakbuf+soffset, 8192-soffset, "0x%lx ", (unsigned long)g_ntohl(naklist[i]))); if ((++j % 8) == 0) { if (firsttime) { proto_tree_add_bytes_format(opt_tree, hf_pgm_opt_nak_list, tvb, ptvcursor_current_offset(cursor), j*4, nakbuf, "List(%d): %s", naks, nakbuf); soffset = 0; firsttime = FALSE; } else { proto_tree_add_bytes_format_value(opt_tree, hf_pgm_opt_nak_list, tvb, ptvcursor_current_offset(cursor), j*4, nakbuf, "%s", nakbuf); soffset = 0; } ptvcursor_advance(cursor, j*4); j = 0; } } if (j) { if (firsttime) { proto_tree_add_bytes_format(opt_tree, hf_pgm_opt_nak_list, tvb, ptvcursor_current_offset(cursor), j*4, nakbuf, "List(%d): %s", naks, nakbuf); } else { proto_tree_add_bytes_format_value(opt_tree, hf_pgm_opt_nak_list, tvb, ptvcursor_current_offset(cursor), j*4, nakbuf, "%s", nakbuf); } ptvcursor_advance(cursor, j*4); } break; } case PGM_OPT_PGMCC_DATA:{ guint16 optdata_afi; TLV_CHECK(ett_pgm_opts_ccdata); ptvcursor_set_tree(cursor, opt_tree); ptvcursor_add_no_advance(cursor, hf_pgm_genopt_end, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_type, 1, ENC_BIG_ENDIAN); if (genopts_len < PGM_OPT_PGMCC_DATA_SIZE) { proto_tree_add_uint_format_value(opt_tree, hf_pgm_genopt_len, tvb, ptvcursor_current_offset(cursor), 1, genopts_len, "%u (bogus, must be >= %u)", genopts_len, PGM_OPT_PGMCC_DATA_SIZE); break; } ptvcursor_add(cursor, hf_pgm_genopt_len, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_opx, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_ccdata_res, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_ccdata_tsp, 4, ENC_BIG_ENDIAN); optdata_afi = tvb_get_ntohs(tvb, ptvcursor_current_offset(cursor)); ti = ptvcursor_add(cursor, hf_pgm_opt_ccdata_afi, 2, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_ccdata_res2, 2, ENC_BIG_ENDIAN); switch (optdata_afi) { case AFNUM_INET: ptvcursor_add(cursor, hf_pgm_opt_ccdata_acker, 4, ENC_BIG_ENDIAN); break; case AFNUM_INET6: ptvcursor_add(cursor, hf_pgm_opt_ccdata_acker6, 16, ENC_NA); break; default: expert_add_info(pinfo, ti, &ei_address_format_invalid); break; } break; } case PGM_OPT_PGMCC_FEEDBACK:{ guint16 optdata_afi; TLV_CHECK(ett_pgm_opts_ccdata); ptvcursor_set_tree(cursor, opt_tree); ptvcursor_add_no_advance(cursor, hf_pgm_genopt_end, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_type, 1, ENC_BIG_ENDIAN); if (genopts_len < PGM_OPT_PGMCC_FEEDBACK_SIZE) { proto_tree_add_uint_format_value(opt_tree, hf_pgm_genopt_len, tvb, ptvcursor_current_offset(cursor), 1, genopts_len, "%u (bogus, must be >= %u)", genopts_len, PGM_OPT_PGMCC_FEEDBACK_SIZE); break; } ptvcursor_add(cursor, hf_pgm_genopt_len, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_opx, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_ccfeedbk_res, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_ccfeedbk_tsp, 4, ENC_BIG_ENDIAN); optdata_afi = tvb_get_ntohs(tvb, ptvcursor_current_offset(cursor)); ti = ptvcursor_add(cursor, hf_pgm_opt_ccfeedbk_afi, 2, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_ccfeedbk_lossrate, 2, ENC_BIG_ENDIAN); switch (optdata_afi) { case AFNUM_INET: ptvcursor_add(cursor, hf_pgm_opt_ccfeedbk_acker, 4, ENC_BIG_ENDIAN); break; case AFNUM_INET6: ptvcursor_add(cursor, hf_pgm_opt_ccfeedbk_acker6, 16, ENC_NA); break; default: expert_add_info(pinfo, ti, &ei_address_format_invalid); break; } break; } case PGM_OPT_NAK_BO_IVL:{ TLV_CHECK(ett_pgm_opts_nak_bo_ivl); ptvcursor_set_tree(cursor, opt_tree); ptvcursor_add_no_advance(cursor, hf_pgm_genopt_end, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_type, 1, ENC_BIG_ENDIAN); if (genopts_len < PGM_OPT_NAK_BO_IVL_SIZE) { proto_tree_add_uint_format_value(opt_tree, hf_pgm_genopt_len, tvb, ptvcursor_current_offset(cursor), 1, genopts_len, "%u (bogus, must be >= %u)", genopts_len, PGM_OPT_NAK_BO_IVL_SIZE); break; } ptvcursor_add(cursor, hf_pgm_genopt_len, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_opx, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_nak_bo_ivl_res, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_nak_bo_ivl_bo_ivl, 4, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_nak_bo_ivl_bo_ivl_sqn, 4, ENC_BIG_ENDIAN); break; } case PGM_OPT_NAK_BO_RNG:{ TLV_CHECK(ett_pgm_opts_nak_bo_rng); ptvcursor_set_tree(cursor, opt_tree); ptvcursor_add_no_advance(cursor, hf_pgm_genopt_end, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_type, 1, ENC_BIG_ENDIAN); if (genopts_len < PGM_OPT_NAK_BO_RNG_SIZE) { proto_tree_add_uint_format_value(opt_tree, hf_pgm_genopt_len, tvb, ptvcursor_current_offset(cursor), 1, genopts_len, "%u (bogus, must be >= %u)", genopts_len, PGM_OPT_NAK_BO_RNG_SIZE); break; } ptvcursor_add(cursor, hf_pgm_genopt_len, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_opx, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_nak_bo_rng_res, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_nak_bo_rng_min_bo_ivl, 4, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_nak_bo_rng_max_bo_ivl, 4, ENC_BIG_ENDIAN); break; } case PGM_OPT_REDIRECT:{ guint16 optdata_afi; TLV_CHECK(ett_pgm_opts_redirect); ptvcursor_set_tree(cursor, opt_tree); ptvcursor_add_no_advance(cursor, hf_pgm_genopt_end, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_type, 1, ENC_BIG_ENDIAN); if (genopts_len < PGM_OPT_REDIRECT_SIZE) { proto_tree_add_uint_format_value(opt_tree, hf_pgm_genopt_len, tvb, ptvcursor_current_offset(cursor), 1, genopts_len, "%u (bogus, must be >= %u)", genopts_len, PGM_OPT_REDIRECT_SIZE); break; } ptvcursor_add(cursor, hf_pgm_genopt_len, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_opx, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_redirect_res, 1, ENC_BIG_ENDIAN); optdata_afi = tvb_get_ntohs(tvb, ptvcursor_current_offset(cursor)); ti = ptvcursor_add(cursor, hf_pgm_opt_redirect_afi, 2, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_redirect_res2, 2, ENC_BIG_ENDIAN); switch (optdata_afi) { case AFNUM_INET: ptvcursor_add(cursor, hf_pgm_opt_redirect_dlr, 4, ENC_BIG_ENDIAN); break; case AFNUM_INET6: ptvcursor_add(cursor, hf_pgm_opt_redirect_dlr6, 16, ENC_NA); break; default: expert_add_info(pinfo, ti, &ei_address_format_invalid); break; } break; } case PGM_OPT_FRAGMENT:{ TLV_CHECK(ett_pgm_opts_fragment); ptvcursor_set_tree(cursor, opt_tree); ptvcursor_add_no_advance(cursor, hf_pgm_genopt_end, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_type, 1, ENC_BIG_ENDIAN); if (genopts_len < PGM_OPT_FRAGMENT_SIZE) { proto_tree_add_uint_format_value(opt_tree, hf_pgm_genopt_len, tvb, ptvcursor_current_offset(cursor), 1, genopts_len, "%u (bogus, must be >= %u)", genopts_len, PGM_OPT_FRAGMENT_SIZE); break; } ptvcursor_add(cursor, hf_pgm_genopt_len, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_genopt_opx, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_fragment_res, 1, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_fragment_first_sqn, 4, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_fragment_offset, 4, ENC_BIG_ENDIAN); ptvcursor_add(cursor, hf_pgm_opt_fragment_total_length, 4, ENC_BIG_ENDIAN); break; } default:{ TLV_CHECK(ett_pgm_opts); ptvcursor_advance(cursor, genopts_len); break; } } opts_total_len -= genopts_len; } return; }
GSList *gromacs_read_ff(const gchar *filename) { gint state, type, num_tokens, ub, ua, ud, i; gchar *line, **buff, **abuff, **dbuff; GSList *list=NULL; struct forcefield_pak *ff; FILE *fp; fp = fopen(filename, "rt"); if (!fp) return(NULL); /* unknown bond, angle, dihedral types */ ub = ua = ud = 0; /* stop auto skip of lines starting with # ... ie #define */ file_skip_comment(FALSE); line = file_read_line(fp); state = -1; while (line) { /* TODO - get rid of leading whitespace, so funny comment lines are properly ignored */ ff = NULL; /* directive processing */ switch(line[0]) { case '[': state = -1; if (g_strrstr(line, "bond")) state = BOND; if (g_strrstr(line, "angle")) state = ANGLE; if (g_strrstr(line, "dihedral")) state = DIHEDRAL; break; /* process #defines */ case '#': if (g_ascii_strncasecmp("#define", line, 7) == 0) { buff = get_tokens(line, 3); abuff = g_strsplit(*(buff+1), "_", -1); #if GTK_MAJOR_VERSION >= 2 && GTK_MINOR_VERSION >= 6 num_tokens = g_strv_length(abuff); #else num_tokens = 0; #endif if (abuff) { if (g_ascii_strncasecmp(*(abuff), "improper", 8) == 0) { if (num_tokens > 4) { ff = ff_type_new(FF_IMPROPER); g_snprintf(ff->atom[0], FF_MAX_SYMBOL, "%s", *(abuff+num_tokens-4)); g_snprintf(ff->atom[1], FF_MAX_SYMBOL, "%s", *(abuff+num_tokens-3)); g_snprintf(ff->atom[2], FF_MAX_SYMBOL, "%s", *(abuff+num_tokens-2)); g_snprintf(ff->atom[3], FF_MAX_SYMBOL, "%s", *(abuff+num_tokens-1)); /* TODO - Y, Z -> X ... since X is wildcard type */ for (i=4 ; i-- ; ) if (ff->atom[i][0] == 'Y' || ff->atom[i][0] == 'Z') ff->atom[i][0] = 'X'; dbuff = get_tokens(line, 6); ff->bond_value = str_to_float(*(dbuff+2)); ff->bond_units = FF_DEG; ff->data[0] = str_to_float(*(dbuff+3)); ff->data[1] = str_to_float(*(dbuff+4)); g_strfreev(dbuff); ff->atoms_current = ff->atoms_expected; ff->data_current = ff->data_expected = 2; list = g_slist_prepend(list, ff); ff = NULL; } } g_strfreev(abuff); } g_strfreev(buff); } state = -1; break; /* comment */ case ';': break; default: /* normal processing */ buff = tokenize(line, &num_tokens); switch (state) { case BOND: if (num_tokens > 4) { type = g_ascii_strtod(*(buff+2), NULL); switch (type) { case 1: ff = ff_type_new(FF_HARMONIC); g_snprintf(ff->atom[0], FF_MAX_SYMBOL, "%s", *(buff+0)); g_snprintf(ff->atom[1], FF_MAX_SYMBOL, "%s", *(buff+1)); /* NB: GROMACS uses nm rather than angs */ ff->bond_value = 10.0 * str_to_float(*(buff+3)); ff->bond_units = FF_ANG; /* nm -> ang correction */ ff->data[0] = 0.01 * str_to_float(*(buff+4)); ff->data_units = FF_KJ; ff->atoms_current = ff->atoms_expected; ff->data_current = ff->data_expected; break; case 3: g_assert(num_tokens > 5); ff = ff_type_new(FF_MORSE); g_snprintf(ff->atom[0], FF_MAX_SYMBOL, "%s", *(buff+0)); g_snprintf(ff->atom[1], FF_MAX_SYMBOL, "%s", *(buff+1)); /* nm -> ang correction */ ff->bond_value = 10.0*str_to_float(*(buff+3)); ff->bond_units = FF_ANG; ff->data[0] = str_to_float(*(buff+4)); ff->data[1] = 0.1 * str_to_float(*(buff+5)); ff->data_units = FF_KJ; ff->atoms_current = ff->atoms_expected; ff->data_current = ff->data_expected; break; default: ub++; } } break; case ANGLE: if (num_tokens > 5) { type = g_ascii_strtod(*(buff+3), NULL); switch (type) { case 1: ff = ff_type_new(FF_3B_HARMONIC); g_snprintf(ff->atom[0], FF_MAX_SYMBOL, "%s", *(buff+0)); g_snprintf(ff->atom[1], FF_MAX_SYMBOL, "%s", *(buff+1)); g_snprintf(ff->atom[2], FF_MAX_SYMBOL, "%s", *(buff+2)); ff->bond_value = str_to_float(*(buff+4)); ff->bond_units = FF_DEG; ff->data[0] = str_to_float(*(buff+5)); /* strictly - kJ/mol rad-2 */ ff->data_units = FF_KJ; ff->atoms_current = ff->atoms_expected; ff->data_current = ff->data_expected; break; default: ua++; } } break; case DIHEDRAL: if (num_tokens > 4) { type = g_ascii_strtod(*(buff+4), NULL); switch (type) { case 1: if (num_tokens < 7) { ud++; break; } ff = ff_type_new(FF_DIHEDRAL); g_snprintf(ff->atom[0], FF_MAX_SYMBOL, "%s", *(buff+0)); g_snprintf(ff->atom[1], FF_MAX_SYMBOL, "%s", *(buff+1)); g_snprintf(ff->atom[2], FF_MAX_SYMBOL, "%s", *(buff+2)); g_snprintf(ff->atom[3], FF_MAX_SYMBOL, "%s", *(buff+3)); ff->bond_value = str_to_float(*(buff+5)); ff->bond_units = FF_DEG; ff->data[0] = str_to_float(*(buff+6)); ff->data_units = FF_KJ; ff->atoms_current = ff->atoms_expected; ff->data_current = ff->data_expected; break; case 3: if (num_tokens < 11) { ud++; break; } ff = ff_type_new(FF_DIHEDRAL_RB); g_snprintf(ff->atom[0], FF_MAX_SYMBOL, "%s", *(buff+0)); g_snprintf(ff->atom[1], FF_MAX_SYMBOL, "%s", *(buff+1)); g_snprintf(ff->atom[2], FF_MAX_SYMBOL, "%s", *(buff+2)); g_snprintf(ff->atom[3], FF_MAX_SYMBOL, "%s", *(buff+3)); ff->data[0] = str_to_float(*(buff+5)); ff->data[1] = str_to_float(*(buff+6)); ff->data[2] = str_to_float(*(buff+7)); ff->data[3] = str_to_float(*(buff+8)); ff->data[4] = str_to_float(*(buff+9)); ff->data[5] = str_to_float(*(buff+10)); ff->data_units = FF_KJ; ff->atoms_current = ff->atoms_expected; ff->data_current = ff->data_expected; break; default: ud++; } } break; } /* add the object to the return list */ if (ff) list = g_slist_prepend(list, ff); g_strfreev(buff); break; } g_free(line); line = file_read_line(fp); } g_free(line); #if DEBUG_GROMACS_READ_FF printf("processed: %d items.\n", g_slist_length(list)); printf("ignored: [bonds = %d] [angles = %d] [dihedrals = %d]\n", ub, ua, ud); /* ff_dump_type(FF_IMPROPER, list); */ #endif file_skip_comment(TRUE); return(list); }
void configure_box (void) { int dlg_width = 60; int dlg_height = 21; char time_out[BUF_TINY] = ""; char *time_out_new; const char *pause_options[] = { N_("&Never"), N_("On dum&b terminals"), N_("Alwa&ys") }; int pause_options_num = G_N_ELEMENTS (pause_options); QuickWidget quick_widgets[] = { /* buttons */ QUICK_BUTTON (38, dlg_width, dlg_height - 3, dlg_height, N_("&Cancel"), B_CANCEL, NULL), QUICK_BUTTON (14, dlg_width, dlg_height - 3, dlg_height, N_("&OK"), B_ENTER, NULL), /* other options */ QUICK_CHECKBOX (dlg_width / 2 + 2, dlg_width, 12, dlg_height, N_("A&uto save setup"), &auto_save_setup), QUICK_CHECKBOX (dlg_width / 2 + 2, dlg_width, 11, dlg_height, N_("Sa&fe delete"), &safe_delete), QUICK_CHECKBOX (dlg_width / 2 + 2, dlg_width, 10, dlg_height, N_("Cd follows lin&ks"), &mc_global.vfs.cd_symlinks), QUICK_CHECKBOX (dlg_width / 2 + 2, dlg_width, 9, dlg_height, N_("Rotating d&ash"), &nice_rotating_dash), QUICK_CHECKBOX (dlg_width / 2 + 2, dlg_width, 8, dlg_height, N_("Co&mplete: show all"), &mc_global.widget.show_all_if_ambiguous), QUICK_CHECKBOX (dlg_width / 2 + 2, dlg_width, 7, dlg_height, N_("Shell &patterns"), &easy_patterns), QUICK_CHECKBOX (dlg_width / 2 + 2, dlg_width, 6, dlg_height, N_("&Drop down menus"), &drop_menus), QUICK_CHECKBOX (dlg_width / 2 + 2, dlg_width, 5, dlg_height, N_("Auto m&enus"), &auto_menu), QUICK_CHECKBOX (dlg_width / 2 + 2, dlg_width, 4, dlg_height, N_("Use internal vie&w"), &use_internal_view), QUICK_CHECKBOX (dlg_width / 2 + 2, dlg_width, 3, dlg_height, N_("Use internal edi&t"), &use_internal_edit), QUICK_GROUPBOX (dlg_width / 2, dlg_width, 2, dlg_height, dlg_width / 2 - 4, 16, N_("Other options")), /* pause options */ QUICK_RADIO (5, dlg_width, 14, dlg_height, pause_options_num, pause_options, &pause_after_run), QUICK_GROUPBOX (3, dlg_width, 13, dlg_height, dlg_width / 2 - 4, 5, N_("Pause after run")), /* Esc key mode */ QUICK_INPUT (10, dlg_width, 11, dlg_height, (const char *) time_out, 8, 0, MC_HISTORY_ESC_TIMEOUT, &time_out_new), QUICK_LABEL (5, dlg_width, 11, dlg_height, N_("Timeout:")), QUICK_CHECKBOX (5, dlg_width, 10, dlg_height, N_("S&ingle press"), &old_esc_mode), QUICK_GROUPBOX (3, dlg_width, 9, dlg_height, dlg_width / 2 - 4, 4, N_("Esc key mode")), /* file operation options */ QUICK_CHECKBOX (5, dlg_width, 7, dlg_height, N_("Preallocate &space"), &mc_global.vfs.preallocate_space), QUICK_CHECKBOX (5, dlg_width, 6, dlg_height, N_("Mkdi&r autoname"), &auto_fill_mkdir_name), QUICK_CHECKBOX (5, dlg_width, 5, dlg_height, N_("Classic pro&gressbar"), &classic_progressbar), QUICK_CHECKBOX (5, dlg_width, 4, dlg_height, N_("Compute tota&ls"), &file_op_compute_totals), QUICK_CHECKBOX (5, dlg_width, 3, dlg_height, N_("&Verbose operation"), &verbose), QUICK_GROUPBOX (3, dlg_width, 2, dlg_height, dlg_width / 2 - 4, 7, N_("File operation options")), QUICK_END }; const size_t qw_num = G_N_ELEMENTS (quick_widgets) - 1; QuickDialog Quick_input = { dlg_width, dlg_height, -1, -1, N_("Configure options"), "[Configuration]", quick_widgets, configure_callback, NULL, TRUE }; int b0_len, b1_len; int b_len, c_len, g_len, l_len; size_t i; #ifdef ENABLE_NLS for (i = 0; i < qw_num; i++) switch (i) { case 0: case 1: /* buttons */ quick_widgets[i].u.button.text = _(quick_widgets[i].u.button.text); break; case 12: case 14: case 18: case 24: /* groupboxes */ quick_widgets[i].u.groupbox.title = _(quick_widgets[i].u.groupbox.title); break; case 13: { /* radio button */ size_t j; for (j = 0; j < (size_t) pause_options_num; j++) pause_options[j] = _(pause_options[j]); } break; case 15: /* input line */ break; case 16: /* label */ quick_widgets[i].u.label.text = _(quick_widgets[i].u.label.text); break; default: /* checkboxes */ quick_widgets[i].u.checkbox.text = _(quick_widgets[i].u.checkbox.text); break; } Quick_input.title = _(Quick_input.title); #endif /* ENABLE_NLS */ /* calculate widget and dialog widths */ /* dialog title */ dlg_width = max (dlg_width, str_term_width1 (Quick_input.title) + 4); /* buttons */ b0_len = str_term_width1 (quick_widgets[0].u.button.text) + 3; b1_len = str_term_width1 (quick_widgets[1].u.button.text) + 5; b_len = b0_len + b1_len + 1; /* checkboxes within groupboxes */ c_len = 0; for (i = 2; i < 24; i++) if ((i < 12) || (i == 17) || (i > 18)) c_len = max (c_len, str_term_width1 (quick_widgets[i].u.checkbox.text) + 3); /* radiobuttons */ for (i = 0; i < (size_t) pause_options_num; i++) c_len = max (c_len, str_term_width1 (pause_options[i]) + 3); /* label + input */ l_len = str_term_width1 (quick_widgets[16].u.label.text); c_len = max (c_len, l_len + 1 + 8); /* groupboxes */ g_len = max (c_len + 2, str_term_width1 (quick_widgets[24].u.groupbox.title) + 4); g_len = max (g_len, str_term_width1 (quick_widgets[18].u.groupbox.title) + 4); g_len = max (g_len, str_term_width1 (quick_widgets[14].u.groupbox.title) + 4); g_len = max (g_len, str_term_width1 (quick_widgets[12].u.groupbox.title) + 4); /* dialog width */ Quick_input.xlen = max (dlg_width, g_len * 2 + 9); Quick_input.xlen = max (Quick_input.xlen, b_len + 2); if ((Quick_input.xlen & 1) != 0) Quick_input.xlen++; /* fix widget parameters */ for (i = 0; i < qw_num; i++) quick_widgets[i].x_divisions = Quick_input.xlen; /* groupboxes */ quick_widgets[14].u.groupbox.width = quick_widgets[18].u.groupbox.width = quick_widgets[24].u.groupbox.width = Quick_input.xlen / 2 - 4; quick_widgets[12].u.groupbox.width = Quick_input.xlen / 2 - 3; /* input */ quick_widgets[15].relative_x = quick_widgets[16].relative_x + l_len + 1; quick_widgets[15].u.input.len = quick_widgets[18].u.groupbox.width - l_len - 4; /* right column */ quick_widgets[12].relative_x = Quick_input.xlen / 2; for (i = 2; i < 12; i++) quick_widgets[i].relative_x = quick_widgets[12].relative_x + 2; /* buttons */ quick_widgets[1].relative_x = (Quick_input.xlen - b_len) / 3; quick_widgets[0].relative_x = 2 * quick_widgets[1].relative_x + b1_len + 1; g_snprintf (time_out, sizeof (time_out), "%d", old_esc_mode_timeout); if (!old_esc_mode) quick_widgets[15].options = quick_widgets[16].options = W_DISABLED; #ifndef HAVE_POSIX_FALLOCATE mc_global.vfs.preallocate_space = FALSE; quick_widgets[19].options = W_DISABLED; #endif if (quick_dialog (&Quick_input) == B_ENTER) old_esc_mode_timeout = atoi (time_out_new); g_free (time_out_new); }
static void _updateAISdata(struct gps_data_t *gpsdata) { /* debug - gpsdata->set #define ONLINE_SET (1u<<1) #define TIME_SET (1u<<2) #define TIMERR_SET (1u<<3) #define LATLON_SET (1u<<4) #define ALTITUDE_SET (1u<<5) #define SPEED_SET (1u<<6) #define TRACK_SET (1u<<7) #define CLIMB_SET (1u<<8) #define STATUS_SET (1u<<9) #define MODE_SET (1u<<10) #define DOP_SET (1u<<11) #define HERR_SET (1u<<12) #define VERR_SET (1u<<13) #define ATTITUDE_SET (1u<<14) #define SATELLITE_SET (1u<<15) #define SPEEDERR_SET (1u<<16) #define TRACKERR_SET (1u<<17) #define CLIMBERR_SET (1u<<18) #define DEVICE_SET (1u<<19) #define DEVICELIST_SET (1u<<20) #define DEVICEID_SET (1u<<21) #define RTCM2_SET (1u<<22) #define RTCM3_SET (1u<<23) #define AIS_SET (1u<<24) #define PACKET_SET (1u<<25) #define SUBFRAME_SET (1u<<26) #define GST_SET (1u<<27) #define VERSION_SET (1u<<28) #define POLICY_SET (1u<<29) #define LOGMESSAGE_SET (1u<<30) #define ERROR_SET (1u<<31) */ // debug //g_print("s52ais:_updateAISdata(): ERROR_SET:%u, AIS_SET:%u [error:%s]\n", // gpsdata->ais.type & ERROR_SET, gpsdata->set & AIS_SET, gpsdata->error); // Types 1,2,3 - Common navigation info if (1==gpsdata->ais.type || 2==gpsdata->ais.type || 3==gpsdata->ais.type) { double lat = gpsdata->ais.type1.lat / 600000.0; double lon = gpsdata->ais.type1.lon / 600000.0; double course = gpsdata->ais.type1.course / 10.0; double speed = gpsdata->ais.type1.speed / 10.0; double heading = gpsdata->ais.type1.heading; int turn = gpsdata->ais.type1.turn; // signed (int): rate of turn int status = gpsdata->ais.type1.status; //g_print("mmsi:%i, lat:%f, lon:%f\n", gpsdata->ais.mmsi, lat, lon); // debug //if (0 == firstmmsi) // firstmmsi = gpsdata->ais.mmsi; //else // if (gpsdata->ais.mmsi != firstmmsi) // return; // heading not available if (511.0 == heading) heading = course; // speed not available if (102.3 == speed) speed = 0.0; //Turn rate is encoded as follows: // 0 - not turning // 1..126 - turning right at up to 708 degrees per minute or higher // -1..-126 - turning left at up to 708 degrees per minute or higher // 127 - turning right at more than 5deg/30s (No TI available) // -127 - turning left at more than 5deg/30s (No TI available) // 128 - (80 hex) indicates no turn information available (default) _setAISSta(gpsdata->ais.mmsi, status, turn); _setAISPos(gpsdata->ais.mmsi, lat, lon, heading); _setAISVec(gpsdata->ais.mmsi, course, speed); return; } // Type 4 - Base Station Report (& Type 11 - UTC and Date Response) if (4 == gpsdata->ais.type) { /* unsigned int year; // UTC year #define AIS_YEAR_NOT_AVAILABLE 0 unsigned int month; // UTC month #define AIS_MONTH_NOT_AVAILABLE 0 unsigned int day; // UTC day #define AIS_DAY_NOT_AVAILABLE 0 unsigned int hour; // UTC hour #define AIS_HOUR_NOT_AVAILABLE 24 unsigned int minute; // UTC minute #define AIS_MINUTE_NOT_AVAILABLE 60 unsigned int second; // UTC second #define AIS_SECOND_NOT_AVAILABLE 60 bool accuracy; // fix quality int lon; // longitude int lat; // latitude unsigned int epfd; // type of position fix device //unsigned int spare; // spare bits bool raim; // RAIM flag unsigned int radio; // radio status bits */ double lat = gpsdata->ais.type4.lat / 600000.0; double lon = gpsdata->ais.type4.lon / 600000.0; char label[AIS_SHIPNAME_MAXLEN+1]; g_snprintf(label, AIS_SHIPNAME_MAXLEN, "%4i-%02i-%02iT%02i:%02i:%02iZ", gpsdata->ais.type4.year, gpsdata->ais.type4.month, gpsdata->ais.type4.day, gpsdata->ais.type4.hour, gpsdata->ais.type4.minute, gpsdata->ais.type4.second); _setAISLab(gpsdata->ais.mmsi, label); _setAISPos(gpsdata->ais.mmsi, lat, lon, 0.0); return; } //Type 5 - Ship static and voyage related data if (5 == gpsdata->ais.type) { /* unsigned int ais_version; // AIS version level unsigned int imo; // IMO identification char callsign[8]; // callsign #define AIS_SHIPNAME_MAXLEN 20 char shipname[AIS_SHIPNAME_MAXLEN+1]; // vessel name unsigned int shiptype; // ship type code // dimension unsigned int to_bow; // dimension to bow unsigned int to_stern; // dimension to stern unsigned int to_port; // dimension to port unsigned int to_starboard; // dimension to starboard unsigned int epfd; // type of position fix deviuce // ETA ? unsigned int month;// UTC month unsigned int day; // UTC day unsigned int hour; // UTC hour unsigned int minute; // UTC minute unsigned int draught; // draft in meters char destination[21]; // ship destination unsigned int dte; // data terminal enable //unsigned int spare; // spare bits */ /* _setAISInfo(gpsdata->ais.mmsi, gpsdata->ais.type5.imo, gpsdata->ais.type5.callsign, gpsdata->ais.type5.shiptype, gpsdata->ais.type5.month, gpsdata->ais.type5.day, gpsdata->ais.type5.hour, gpsdata->ais.type5.minute, gpsdata->ais.type5.draught, gpsdata->ais.type5.destination); */ _setAISLab(gpsdata->ais.mmsi, gpsdata->ais.type5.shipname); _setAISDim(gpsdata->ais.mmsi, gpsdata->ais.type5.to_bow, gpsdata->ais.type5.to_stern, gpsdata->ais.type5.to_port, gpsdata->ais.type5.to_starboard); return; } // Type 8 - Broadcast Binary Message if (8 == gpsdata->ais.type) { /* unsigned int dac; // Designated Area Code unsigned int fid; // Functional ID #define AIS_TYPE8_BINARY_MAX 952 // 952 bits size_t bitcount; // bit count of the data */ // followed by: //union { // char bitdata[(AIS_TYPE8_BINARY_MAX + 7) / 8]; // 119.875 bytes (!), but (MAX+8)/8 == 120 bytes // ... // AIS MSG TYPE 8: Broadcast Binary Message [mmsi:3160026, dac:316, fid:19] // DAC 316 - Canada // FID 19 - ??? //g_print("s52ais:_updateAISdata(): AIS MSG TYPE 8 - Broadcast Binary Message [mmsi:%i, dac:%i, fid:%i, bitdata:%s]\n", // gpsdata->ais.mmsi, gpsdata->ais.type8.dac, gpsdata->ais.type8.fid, gpsdata->ais.type8.bitdata); // add a dummy entry to signal that GPSD is on-line //_setAISLab(gpsdata->ais.mmsi, "AIS MSG TYPE 8 - Broadcast Binary Message"); //_setAISLab(gpsdata->ais.mmsi, "Broadcast Bin Msg"); return; } // Type 20 - Data Link Management Message if (20 == gpsdata->ais.type) { // add a dummy entry to signal that GPSD is on-line //_setAISLab(gpsdata->ais.mmsi, "AIS MSG TYPE 20 - Data Link Management Message"); //_setAISLab(gpsdata->ais.mmsi, "Data Link Mng Msg"); return; } // debug g_print("s52ais:_updateAISdata(): DEBUG - SKIP AIS MSG TYPE:%u, AIS_SET:%llu [error:%s]\n", gpsdata->ais.type, gpsdata->set & AIS_SET, gpsdata->error); // FIXME: // Type 18 // Type 24 return; }
static char *_s52_send_cmd(const char *command, const char *params) { // debug //g_print("s52ais:_s52_send_cmd(): start:%s\n", params); if (NULL == _s52_connection) { g_print("s52ais:_s52_send_cmd(): fail - no conection\n"); return NULL; } GSocket *socket = g_socket_connection_get_socket(_s52_connection); if (NULL == socket) { g_print("s52ais:_s52_send_cmd(): fail - no socket\n"); return NULL; } GError *error = NULL; guint n = 0; // build a full JSON object n = g_snprintf(_response, BUFSZ, "{\"id\":%i,\"method\":\"%s\",\"params\":[%s]}\n", _request_id++, command, params); if (n > BUFSZ) { g_print("s52ais:_s52_send_cmd():g_snprintf(): no space in buffer\n"); return NULL; } _response[n] = '\0'; //g_print("s52ais:_s52_send_cmd(): sending:%s", _response); gssize szsnd = g_socket_send_with_blocking(socket, _response, n, FALSE, NULL, &error); if ((NULL!=error) || (0==szsnd) || (-1==szsnd)) { // 0 - connection was closed by the peer // -1 - on error if (NULL == error) g_print("s52ais:_s52_send_cmd():ERROR:g_socket_send_with_blocking(): connection close [%s]\n", _response); else g_print("s52ais:_s52_send_cmd():ERROR:g_socket_send_with_blocking(): %s [%i:%s]\n", error->message, error->code, _response); _s52_connection = NULL; // reset connection return NULL; } //g_print("s52ais:_s52_send_cmd(): sended:%s", _response); // wait response - blocking socket int szrcv = g_socket_receive_with_blocking(socket, _response, BUFSZ, TRUE, NULL, &error); //gssize szrcv = g_socket_receive_with_blocking(socket, _response, BUFSZ, FALSE, NULL, &error); //if ((NULL!=error) || (0==szrcv) || (-1==szrcv)) { if (NULL != error) { g_print("s52ais:_s52_send_cmd():ERROR:g_socket_receive_with_blocking(): %s [%i:%s]\n", error->message, error->code, _response); _s52_connection = NULL; // reset connection return NULL; } if ((0==szrcv) || (-1==szrcv)) { // 0 - connection was closed by the peer // -1 - on error g_print("s52ais:_s52_send_cmd():ERROR:g_socket_receive_with_blocking(): szrcv:%i\n", szrcv); _s52_connection = NULL; // reset connection return NULL; } _response[szrcv] = '\0'; //g_print("s52ais:_s52_send_cmd(): received:%s\n", _response); gchar *result = g_strrstr(_response, "result"); if (NULL == result) { g_print("s52ais:_s52_send_cmd():no result [_response:'%s']\n", _response); return NULL; } return _response; }
frs_return_t FollowStreamDialog::follow_show(char *buffer, size_t nchars, gboolean is_from_server, guint32 packet_num, guint32 *global_pos) { gchar initbuf[256]; guint32 current_pos; static const gchar hexchars[16] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'}; switch (follow_info_.show_type) { case SHOW_EBCDIC: { /* If our native arch is ASCII, call: */ EBCDIC_to_ASCII((guint8*)buffer, (guint) nchars); sanitize_buffer(buffer, nchars); QByteArray ba = QByteArray(buffer, (int)nchars); add_text(ba, is_from_server, packet_num); break; } case SHOW_ASCII: { /* If our native arch is EBCDIC, call: * ASCII_TO_EBCDIC(buffer, nchars); */ sanitize_buffer(buffer, nchars); sanitize_buffer(buffer, nchars); QByteArray ba = QByteArray(buffer, (int)nchars); add_text(ba, is_from_server, packet_num); break; } case SHOW_RAW: // UTF-8 { // The QString docs say that invalid characters will be replaced with // replacement characters or removed. It would be nice if we could // explicitly choose one or the other. QString utf8 = QString::fromUtf8(buffer, (int)nchars); add_text(utf8, is_from_server, packet_num); break; } case SHOW_HEXDUMP: current_pos = 0; while (current_pos < nchars) { gchar hexbuf[256]; int i; gchar *cur = hexbuf, *ascii_start; /* is_from_server indentation : put 4 spaces at the * beginning of the string */ /* XXX - We might want to prepend each line with "C" or "S" instead. */ if (is_from_server && follow_info_.show_stream == BOTH_HOSTS) { memset(cur, ' ', 4); cur += 4; } cur += g_snprintf(cur, 20, "%08X ", *global_pos); /* 49 is space consumed by hex chars */ ascii_start = cur + 49; for (i = 0; i < 16 && current_pos + i < nchars; i++) { *cur++ = hexchars[(buffer[current_pos + i] & 0xf0) >> 4]; *cur++ = hexchars[buffer[current_pos + i] & 0x0f]; *cur++ = ' '; if (i == 7) *cur++ = ' '; } /* Fill it up if column isn't complete */ while (cur < ascii_start) *cur++ = ' '; /* Now dump bytes as text */ for (i = 0; i < 16 && current_pos + i < nchars; i++) { *cur++ = (isprint((guchar)buffer[current_pos + i]) ? buffer[current_pos + i] : '.' ); if (i == 7) { *cur++ = ' '; } } current_pos += i; (*global_pos) += i; *cur++ = '\n'; *cur = 0; add_text(hexbuf, is_from_server, packet_num); } break; case SHOW_CARRAY: current_pos = 0; g_snprintf(initbuf, sizeof(initbuf), "char peer%d_%d[] = { /* Packet %u */\n", is_from_server ? 1 : 0, is_from_server ? server_buffer_count_++ : client_buffer_count_++, packet_num); add_text(initbuf, is_from_server, packet_num); while (current_pos < nchars) { gchar hexbuf[256]; int i, cur; cur = 0; for (i = 0; i < 8 && current_pos + i < nchars; i++) { /* Prepend entries with "0x" */ hexbuf[cur++] = '0'; hexbuf[cur++] = 'x'; hexbuf[cur++] = hexchars[(buffer[current_pos + i] & 0xf0) >> 4]; hexbuf[cur++] = hexchars[buffer[current_pos + i] & 0x0f]; /* Delimit array entries with a comma */ if (current_pos + i + 1 < nchars) hexbuf[cur++] = ','; hexbuf[cur++] = ' '; } /* Terminate the array if we are at the end */ if (current_pos + i == nchars) { hexbuf[cur++] = '}'; hexbuf[cur++] = ';'; } current_pos += i; (*global_pos) += i; hexbuf[cur++] = '\n'; hexbuf[cur] = 0; add_text(hexbuf, is_from_server, packet_num); } break; case SHOW_YAML: { QString yaml_text; const int base64_raw_len = 57; // Encodes to 76 bytes, common in RFCs current_pos = 0; if (packet_num != last_packet_) { yaml_text.append(QString("# Packet %1\npeer%2_%3: !!binary |\n") .arg(packet_num) .arg(is_from_server ? 1 : 0) .arg(is_from_server ? server_buffer_count_++ : client_buffer_count_++)); } while (current_pos < nchars) { int len = current_pos + base64_raw_len < nchars ? base64_raw_len : (int) nchars - current_pos; QByteArray base64_data(&buffer[current_pos], len); yaml_text += " " + base64_data.toBase64() + "\n"; current_pos += len; (*global_pos) += len; } add_text(yaml_text, is_from_server, packet_num); break; } } if (last_packet_ == 0) { last_from_server_ = is_from_server; } if (packet_num != last_packet_) { last_packet_ = packet_num; if (is_from_server) { server_packet_count_++; } else { client_packet_count_++; } if (last_from_server_ != is_from_server) { last_from_server_ = is_from_server; turns_++; } } return FRS_OK; }
void ctcp_handle (session *sess, char *to, char *nick, char *ip, char *msg, char *word[], char *word_eol[], int id, const message_tags_data *tags_data) { char *po; session *chansess; server *serv = sess->server; char outbuf[1024]; int ctcp_offset = 2; if (serv->have_idmsg && (word[4][1] == '+' || word[4][1] == '-') ) ctcp_offset = 3; /* consider DCC to be different from other CTCPs */ if (!g_ascii_strncasecmp (msg, "DCC", 3)) { /* but still let CTCP replies override it */ if (!ctcp_check (sess, nick, word, word_eol, word[4] + ctcp_offset)) { if (!ignore_check (word[1], IG_DCC)) handle_dcc (sess, nick, word, word_eol, tags_data); } return; } /* consider ACTION to be different from other CTCPs. Check ignore as if it was a PRIV/CHAN. */ if (!g_ascii_strncasecmp (msg, "ACTION ", 7)) { if (is_channel (serv, to)) { /* treat a channel action as a CHAN */ if (ignore_check (word[1], IG_CHAN)) return; } else { /* treat a private action as a PRIV */ if (ignore_check (word[1], IG_PRIV)) return; } /* but still let CTCP replies override it */ if (ctcp_check (sess, nick, word, word_eol, word[4] + ctcp_offset)) goto generic; inbound_action (sess, to, nick, ip, msg + 7, FALSE, id, tags_data); return; } if (ignore_check (word[1], IG_CTCP)) return; if (!g_ascii_strcasecmp (msg, "VERSION") && !prefs.pchat_irc_hide_version) { #ifdef _WIN32 g_snprintf (outbuf, sizeof (outbuf), "VERSION PChat "PACKAGE_VERSION" [x%d] / %s", get_cpu_arch (), get_sys_str (1)); #else g_snprintf (outbuf, sizeof (outbuf), "VERSION PChat "PACKAGE_VERSION" / %s", get_sys_str (1)); #endif serv->p_nctcp (serv, nick, outbuf); } if (!ctcp_check (sess, nick, word, word_eol, word[4] + ctcp_offset)) { if (!g_ascii_strncasecmp (msg, "SOUND", 5)) { po = strchr (word[5], '\001'); if (po) po[0] = 0; if (is_channel (sess->server, to)) { chansess = find_channel (sess->server, to); if (!chansess) chansess = sess; EMIT_SIGNAL_TIMESTAMP (XP_TE_CTCPSNDC, chansess, word[5], nick, to, NULL, 0, tags_data->timestamp); } else { EMIT_SIGNAL_TIMESTAMP (XP_TE_CTCPSND, sess->server->front_session, word[5], nick, NULL, NULL, 0, tags_data->timestamp); } /* don't let IRCers specify path */ #ifdef _WIN32 if (strchr (word[5], '/') == NULL && strchr (word[5], '\\') == NULL) #else if (strchr (word[5], '/') == NULL) #endif sound_play (word[5], TRUE); return; } } generic: po = strchr (msg, '\001'); if (po) po[0] = 0; if (!is_channel (sess->server, to)) { EMIT_SIGNAL_TIMESTAMP (XP_TE_CTCPGEN, sess->server->front_session, msg, nick, NULL, NULL, 0, tags_data->timestamp); } else { chansess = find_channel (sess->server, to); if (!chansess) chansess = sess; EMIT_SIGNAL_TIMESTAMP (XP_TE_CTCPGENC, chansess, msg, nick, to, NULL, 0, tags_data->timestamp); } }
/* * This routine creates one entry in the list of protocol dissector * that have been changed. It is called by the g_hash_foreach routine * once for each changed entry in a dissector table. * * @param table_name The table name in which this dissector is found. * * @param key A pointer to the key for this entry in the dissector * hash table. This is generally the numeric selector of the * protocol, i.e. the ethernet type code, IP port number, TCP port * number, etc. * * @param value A pointer to the value for this entry in the dissector * hash table. This is an opaque pointer that can only be handed back * to routine in the file packet.c * * @param user_data A pointer to the list in which this information * should be stored. */ static void decode_build_show_list (const gchar *table_name, ftenum_t selector_type, gpointer key, gpointer value, gpointer user_data) { dissector_handle_t current, initial; const gchar *current_proto_name, *initial_proto_name; gchar *selector_name; gchar string1[20]; da_entry_t *entry; entry = g_new(da_entry_t,1); g_assert(user_data); g_assert(value); current = dtbl_entry_get_handle((dtbl_entry_t *)value); if (current == NULL) current_proto_name = DECODE_AS_NONE; else current_proto_name = dissector_handle_get_short_name(current); initial = dtbl_entry_get_initial_handle((dtbl_entry_t *)value); if (initial == NULL) initial_proto_name = DECODE_AS_NONE; else initial_proto_name = dissector_handle_get_short_name(initial); switch (selector_type) { case FT_UINT8: case FT_UINT16: case FT_UINT24: case FT_UINT32: switch (get_dissector_table_base(table_name)) { case BASE_DEC: g_snprintf(string1, sizeof(string1), "%u", GPOINTER_TO_UINT(key)); break; case BASE_HEX: switch (get_dissector_table_selector_type(table_name)) { case FT_UINT8: g_snprintf(string1, sizeof(string1), "0x%02x", GPOINTER_TO_UINT(key)); break; case FT_UINT16: g_snprintf(string1, sizeof(string1), "0x%04x", GPOINTER_TO_UINT(key)); break; case FT_UINT24: g_snprintf(string1, sizeof(string1), "0x%06x", GPOINTER_TO_UINT(key)); break; case FT_UINT32: g_snprintf(string1, sizeof(string1), "0x%08x", GPOINTER_TO_UINT(key)); break; default: g_assert_not_reached(); break; } break; case BASE_OCT: g_snprintf(string1, sizeof(string1), "%#o", GPOINTER_TO_UINT(key)); break; } selector_name = string1; break; case FT_STRING: case FT_STRINGZ: selector_name = (gchar *)key; break; default: g_assert_not_reached(); selector_name = NULL; break; } decode_add_to_show_list ( user_data, get_dissector_table_ui_name(table_name), selector_name, initial_proto_name, current_proto_name); entry->table = g_strdup(table_name); entry->selector = GPOINTER_TO_UINT(key); entry->initial = g_strdup(initial_proto_name); entry->current = g_strdup(current_proto_name); da_entries = g_slist_append(da_entries, entry); }
void chown_advanced_cmd (void) { /* Number of files at startup */ int files_on_begin; files_on_begin = max (1, current_panel->marked); do { /* do while any files remaining */ int file_idx; char buffer[BUF_MEDIUM]; vfs_path_t *vpath; int result; init_chown_advanced (); if (current_panel->marked) fname = next_file (); /* next marked file */ else fname = selection (current_panel)->fname; /* single file */ vpath = vfs_path_from_str (fname); if (mc_stat (vpath, sf_stat) != 0) { /* get status of file */ destroy_dlg (ch_dlg); vfs_path_free (vpath); break; } ch_cmode = sf_stat->st_mode; file_idx = files_on_begin == 1 ? 1 : (files_on_begin - current_panel->marked + 1); g_snprintf (buffer, sizeof (buffer), "%s (%d/%d)", str_fit_to_term (fname, WIDGET (ch_dlg)->cols - 20, J_LEFT_FIT), file_idx, files_on_begin); label_set_text (l_filename, buffer); chown_refresh (); update_ownership (); result = run_dlg (ch_dlg); switch (result) { case B_CANCEL: end_chown = TRUE; break; case B_ENTER: need_update = TRUE; if (mc_chmod (vpath, get_mode ()) == -1) message (D_ERROR, MSG_ERROR, _("Cannot chmod \"%s\"\n%s"), fname, unix_error_string (errno)); /* call mc_chown only, if mc_chmod didn't fail */ else if (mc_chown (vpath, (ch_flags[9] == '+') ? sf_stat->st_uid : (uid_t) (-1), (ch_flags[10] == '+') ? sf_stat->st_gid : (gid_t) (-1)) == -1) message (D_ERROR, MSG_ERROR, _("Cannot chown \"%s\"\n%s"), fname, unix_error_string (errno)); break; case B_SETALL: apply_advanced_chowns (sf_stat); break; case B_SKIP: break; } if (current_panel->marked && result != B_CANCEL) { do_file_mark (current_panel, current_file, 0); need_update = TRUE; } destroy_dlg (ch_dlg); vfs_path_free (vpath); } while (current_panel->marked && !end_chown); chown_advanced_done (); }
GimpPlugInShm * gimp_plug_in_shm_new (void) { /* allocate a piece of shared memory for use in transporting tiles * to plug-ins. if we can't allocate a piece of shared memory then * we'll fall back on sending the data over the pipe. */ GimpPlugInShm *shm = g_slice_new0 (GimpPlugInShm); shm->shm_ID = -1; #if defined(USE_SYSV_SHM) /* Use SysV shared memory mechanisms for transferring tile data. */ { shm->shm_ID = shmget (IPC_PRIVATE, TILE_MAP_SIZE, IPC_CREAT | 0600); if (shm->shm_ID != -1) { shm->shm_addr = (guchar *) shmat (shm->shm_ID, NULL, 0); if (shm->shm_addr == (guchar *) -1) { g_printerr ("shmat() failed: %s\n" ERRMSG_SHM_DISABLE, g_strerror (errno)); shmctl (shm->shm_ID, IPC_RMID, NULL); shm->shm_ID = -1; } #ifdef IPC_RMID_DEFERRED_RELEASE if (shm->shm_addr != (guchar *) -1) shmctl (shm->shm_ID, IPC_RMID, NULL); #endif } else { g_printerr ("shmget() failed: %s\n" ERRMSG_SHM_DISABLE, g_strerror (errno)); } } #elif defined(USE_WIN32_SHM) /* Use Win32 shared memory mechanisms for transferring tile data. */ { gint pid; gchar fileMapName[MAX_PATH]; /* Our shared memory id will be our process ID */ pid = GetCurrentProcessId (); /* From the id, derive the file map name */ g_snprintf (fileMapName, sizeof (fileMapName), "GIMP%d.SHM", pid); /* Create the file mapping into paging space */ shm->shm_handle = CreateFileMapping (INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, TILE_MAP_SIZE, fileMapName); if (shm->shm_handle) { /* Map the shared memory into our address space for use */ shm->shm_addr = (guchar *) MapViewOfFile (shm->shm_handle, FILE_MAP_ALL_ACCESS, 0, 0, TILE_MAP_SIZE); /* Verify that we mapped our view */ if (shm->shm_addr) { shm->shm_ID = pid; } else { g_printerr ("MapViewOfFile error: %d... " ERRMSG_SHM_DISABLE, GetLastError ()); } } else { g_printerr ("CreateFileMapping error: %d... " ERRMSG_SHM_DISABLE, GetLastError ()); } } #elif defined(USE_POSIX_SHM) /* Use POSIX shared memory mechanisms for transferring tile data. */ { gint pid; gchar shm_handle[32]; gint shm_fd; /* Our shared memory id will be our process ID */ pid = get_pid (); /* From the id, derive the file map name */ g_snprintf (shm_handle, sizeof (shm_handle), "/gimp-shm-%d", pid); /* Create the file mapping into paging space */ shm_fd = shm_open (shm_handle, O_RDWR | O_CREAT, 0600); if (shm_fd != -1) { if (ftruncate (shm_fd, TILE_MAP_SIZE) != -1) { /* Map the shared memory into our address space for use */ shm->shm_addr = (guchar *) mmap (NULL, TILE_MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0); /* Verify that we mapped our view */ if (shm->shm_addr != MAP_FAILED) { shm->shm_ID = pid; } else { g_printerr ("mmap() failed: %s\n" ERRMSG_SHM_DISABLE, g_strerror (errno)); shm_unlink (shm_handle); } } else { g_printerr ("ftruncate() failed: %s\n" ERRMSG_SHM_DISABLE, g_strerror (errno)); shm_unlink (shm_handle); } close (shm_fd); } else { g_printerr ("shm_open() failed: %s\n" ERRMSG_SHM_DISABLE, g_strerror (errno)); } } #endif if (shm->shm_ID == -1) { g_slice_free (GimpPlugInShm, shm); shm = NULL; } else { GIMP_LOG (SHM, "attached shared memory segment ID = %d", shm->shm_ID); } return shm; }
static gchar * _watermark_get_svgdoc( dt_iop_module_t *self, dt_iop_watermark_data_t *data, const dt_image_t *image) { gsize length; gchar *svgdoc=NULL; gchar configdir[1024],datadir[1024], *filename; dt_loc_get_datadir(datadir, 1024); dt_loc_get_user_config_dir(configdir, 1024); g_strlcat(datadir,"/watermarks/",1024); g_strlcat(configdir,"/watermarks/",1024); g_strlcat(datadir,data->filename,1024); g_strlcat(configdir,data->filename,1024); if (g_file_test(configdir,G_FILE_TEST_EXISTS)) filename=configdir; else if (g_file_test(datadir,G_FILE_TEST_EXISTS)) filename=datadir; else return NULL; gchar *svgdata=NULL; char datetime[200]; // EXIF datetime struct tm tt_exif = {0}; if(sscanf(image->exif_datetime_taken,"%d:%d:%d %d:%d:%d", &tt_exif.tm_year, &tt_exif.tm_mon, &tt_exif.tm_mday, &tt_exif.tm_hour, &tt_exif.tm_min, &tt_exif.tm_sec ) == 6 ) { tt_exif.tm_year-=1900; tt_exif.tm_mon--; } // Current datetime struct tm tt_cur = {0}; time_t t = time(NULL); (void)localtime_r(&t, &tt_cur); if( g_file_get_contents( filename, &svgdata, &length, NULL) ) { // File is loaded lets substitute strings if found... // Darktable internal svgdoc = _string_substitute(svgdata,"$(DARKTABLE.NAME)",PACKAGE_NAME); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } svgdoc = _string_substitute(svgdata,"$(DARKTABLE.VERSION)",PACKAGE_VERSION); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // Current image ID gchar buffer[1024]; g_snprintf(buffer,1024,"%d",image->id); svgdoc = _string_substitute(svgdata,"$(IMAGE.ID)",buffer); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // Current image dt_image_print_exif(image,buffer,1024); svgdoc = _string_substitute(svgdata,"$(IMAGE.EXIF)",buffer); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // Image exif // EXIF date svgdoc = _string_substitute(svgdata,"$(EXIF.DATE)",image->exif_datetime_taken); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(EXIF.DATE.SECOND) -- 00..60 strftime(datetime, sizeof(datetime), "%S", &tt_exif); svgdoc = _string_substitute(svgdata,"$(EXIF.DATE.SECOND)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(EXIF.DATE.MINUTE) -- 00..59 strftime(datetime, sizeof(datetime), "%M", &tt_exif); svgdoc = _string_substitute(svgdata,"$(EXIF.DATE.MINUTE)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(EXIF.DATE.HOUR) -- 00..23 strftime(datetime, sizeof(datetime), "%H", &tt_exif); svgdoc = _string_substitute(svgdata,"$(EXIF.DATE.HOUR)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(EXIF.DATE.HOUR_AMPM) -- 01..12 strftime(datetime, sizeof(datetime), "%I %p", &tt_exif); svgdoc = _string_substitute(svgdata,"$(EXIF.DATE.HOUR_AMPM)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(EXIF.DATE.DAY) -- 01..31 strftime(datetime, sizeof(datetime), "%d", &tt_exif); svgdoc = _string_substitute(svgdata,"$(EXIF.DATE.DAY)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(EXIF.DATE.MONTH) -- 01..12 strftime(datetime, sizeof(datetime), "%m", &tt_exif); svgdoc = _string_substitute(svgdata,"$(EXIF.DATE.MONTH)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(EXIF.DATE.SHORT_MONTH) -- Jan, Feb, .., Dec, localized strftime(datetime, sizeof(datetime), "%b", &tt_exif); svgdoc = _string_substitute(svgdata,"$(EXIF.DATE.SHORT_MONTH)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(EXIF.DATE.LONG_MONTH) -- January, February, .., December, localized strftime(datetime, sizeof(datetime), "%B", &tt_exif); svgdoc = _string_substitute(svgdata,"$(EXIF.DATE.LONG_MONTH)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(EXIF.DATE.SHORT_YEAR) -- 12 strftime(datetime, sizeof(datetime), "%y", &tt_exif); svgdoc = _string_substitute(svgdata,"$(EXIF.DATE.SHORT_YEAR)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(EXIF.DATE.LONG_YEAR) -- 2012 strftime(datetime, sizeof(datetime), "%Y", &tt_exif); svgdoc = _string_substitute(svgdata,"$(EXIF.DATE.LONG_YEAR)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // Current date // $(DATE) -- YYYY: dt_gettime_t(datetime, t); svgdoc = _string_substitute(svgdata,"$(DATE)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(DATE.SECOND) -- 00..60 strftime(datetime, sizeof(datetime), "%S", &tt_cur); svgdoc = _string_substitute(svgdata,"$(DATE.SECOND)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(DATE.MINUTE) -- 00..59 strftime(datetime, sizeof(datetime), "%M", &tt_cur); svgdoc = _string_substitute(svgdata,"$(DATE.MINUTE)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(DATE.HOUR) -- 00..23 strftime(datetime, sizeof(datetime), "%H", &tt_cur); svgdoc = _string_substitute(svgdata,"$(DATE.HOUR)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(DATE.HOUR_AMPM) -- 01..12 strftime(datetime, sizeof(datetime), "%I %p", &tt_cur); svgdoc = _string_substitute(svgdata,"$(DATE.HOUR_AMPM)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(DATE.DAY) -- 01..31 strftime(datetime, sizeof(datetime), "%d", &tt_cur); svgdoc = _string_substitute(svgdata,"$(DATE.DAY)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(DATE.MONTH) -- 01..12 strftime(datetime, sizeof(datetime), "%m", &tt_cur); svgdoc = _string_substitute(svgdata,"$(DATE.MONTH)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(DATE.SHORT_MONTH) -- Jan, Feb, .., Dec, localized strftime(datetime, sizeof(datetime), "%b", &tt_cur); svgdoc = _string_substitute(svgdata,"$(DATE.SHORT_MONTH)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(DATE.LONG_MONTH) -- January, February, .., December, localized strftime(datetime, sizeof(datetime), "%B", &tt_cur); svgdoc = _string_substitute(svgdata,"$(DATE.LONG_MONTH)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(DATE.SHORT_YEAR) -- 12 strftime(datetime, sizeof(datetime), "%y", &tt_cur); svgdoc = _string_substitute(svgdata,"$(DATE.SHORT_YEAR)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // $(DATE.LONG_YEAR) -- 2012 strftime(datetime, sizeof(datetime), "%Y", &tt_cur); svgdoc = _string_substitute(svgdata,"$(DATE.LONG_YEAR)",datetime); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } svgdoc = _string_substitute(svgdata,"$(EXIF.MAKER)",image->exif_maker); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } svgdoc = _string_substitute(svgdata,"$(EXIF.MODEL)",image->exif_model); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } svgdoc = _string_substitute(svgdata,"$(EXIF.LENS)",image->exif_lens); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } svgdoc = _string_substitute(svgdata,"$(IMAGE.FILENAME)",image->filename); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } // TODO: auto generate that code? GList * res; res = dt_metadata_get(image->id, "Xmp.dc.creator", NULL); svgdoc = _string_substitute(svgdata,"$(Xmp.dc.creator)",(res?res->data:"")); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } if( res ) { g_free(res->data); g_list_free(res); } res = dt_metadata_get(image->id, "Xmp.dc.publisher", NULL); svgdoc = _string_substitute(svgdata,"$(Xmp.dc.publisher)",(res?res->data:"")); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } if( res ) { g_free(res->data); g_list_free(res); } res = dt_metadata_get(image->id, "Xmp.dc.title", NULL); svgdoc = _string_substitute(svgdata,"$(Xmp.dc.title)",(res?res->data:"")); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } if( res ) { g_free(res->data); g_list_free(res); } res = dt_metadata_get(image->id, "Xmp.dc.description", NULL); svgdoc = _string_substitute(svgdata,"$(Xmp.dc.description)",(res?res->data:"")); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } if( res ) { g_free(res->data); g_list_free(res); } res = dt_metadata_get(image->id, "Xmp.dc.rights", NULL); svgdoc = _string_substitute(svgdata,"$(Xmp.dc.rights)",(res?res->data:"")); if( svgdoc != svgdata ) { g_free(svgdata); svgdata = svgdoc; } if( res ) { g_free(res->data); g_list_free(res); } } return svgdoc; }
static DiaSvgRenderer * new_svg_renderer(DiagramData *data, const char *filename) { DiaSvgRenderer *renderer; SvgRenderer *svg_renderer; FILE *file; gchar buf[512]; time_t time_now; Rectangle *extent; const char *name; xmlDtdPtr dtd; file = g_fopen(filename, "w"); if (file==NULL) { message_error(_("Can't open output file %s: %s\n"), dia_message_filename(filename), strerror(errno)); return NULL; } fclose(file); /* we need access to our base object */ renderer = DIA_SVG_RENDERER (g_object_new(SVG_TYPE_RENDERER, NULL)); renderer->filename = g_strdup(filename); renderer->dash_length = 1.0; renderer->dot_length = 0.2; renderer->saved_line_style = LINESTYLE_SOLID; /* apparently most svg readers don't like small values, especially not in the viewBox attribute */ renderer->scale = 20.0; /* set up the root node */ renderer->doc = xmlNewDoc((const xmlChar *)"1.0"); renderer->doc->encoding = xmlStrdup((const xmlChar *)"UTF-8"); renderer->doc->standalone = FALSE; dtd = xmlCreateIntSubset(renderer->doc, (const xmlChar *)"svg", (const xmlChar *)"-//W3C//DTD SVG 1.0//EN", (const xmlChar *)"http://www.w3.org/TR/2001/PR-SVG-20010719/DTD/svg10.dtd"); xmlAddChild((xmlNodePtr) renderer->doc, (xmlNodePtr) dtd); renderer->root = xmlNewDocNode(renderer->doc, NULL, (const xmlChar *)"svg", NULL); xmlAddSibling(renderer->doc->children, (xmlNodePtr) renderer->root); /* add namespaces to make strict parsers happy, e.g. Firefox */ svg_renderer = SVG_RENDERER (renderer); /* set the extents of the SVG document */ extent = &data->extents; g_snprintf(buf, sizeof(buf), "%dcm", (int)ceil((extent->right - extent->left))); xmlSetProp(renderer->root, (const xmlChar *)"width", (xmlChar *) buf); g_snprintf(buf, sizeof(buf), "%dcm", (int)ceil((extent->bottom - extent->top))); xmlSetProp(renderer->root, (const xmlChar *)"height", (xmlChar *) buf); g_snprintf(buf, sizeof(buf), "%d %d %d %d", (int)floor(extent->left * renderer->scale), (int)floor(extent->top * renderer->scale), (int)ceil((extent->right - extent->left) * renderer->scale), (int)ceil((extent->bottom - extent->top) * renderer->scale)); xmlSetProp(renderer->root, (const xmlChar *)"viewBox", (xmlChar *) buf); xmlSetProp(renderer->root,(const xmlChar *)"xmlns", (const xmlChar *)"http://www.w3.org/2000/svg"); xmlSetProp(renderer->root,(const xmlChar *)"xmlns", (const xmlChar *)"http://www.w3.org/2000/svg"); xmlSetProp(renderer->root,(const xmlChar *)"xmlns:xlink", (const xmlChar *)"http://www.w3.org/1999/xlink"); time_now = time(NULL); name = g_get_user_name(); #if 0 /* some comments at the top of the file ... */ xmlAddChild(renderer->root, xmlNewText("\n")); xmlAddChild(renderer->root, xmlNewComment("Dia-Version: "VERSION)); xmlAddChild(renderer->root, xmlNewText("\n")); g_snprintf(buf, sizeof(buf), "File: %s", dia->filename); xmlAddChild(renderer->root, xmlNewComment(buf)); xmlAddChild(renderer->root, xmlNewText("\n")); g_snprintf(buf, sizeof(buf), "Date: %s", ctime(&time_now)); buf[strlen(buf)-1] = '\0'; /* remove the trailing new line */ xmlAddChild(renderer->root, xmlNewComment(buf)); xmlAddChild(renderer->root, xmlNewText("\n")); g_snprintf(buf, sizeof(buf), "For: %s", name); xmlAddChild(renderer->root, xmlNewComment(buf)); xmlAddChild(renderer->root, xmlNewText("\n\n")); xmlNewChild(renderer->root, NULL, "title", dia->filename); #endif return renderer; }
static void mtp3_addr_to_str_buf(const mtp3_addr_pc_t *addr_pc_p, gchar *buf, int buf_len) { switch (mtp3_addr_fmt) { case MTP3_ADDR_FMT_DEC: switch (addr_pc_p->type) { case ITU_STANDARD: g_snprintf(buf, buf_len, "%u", addr_pc_p->pc & ITU_PC_MASK); break; case JAPAN_STANDARD: g_snprintf(buf, buf_len, "%u", addr_pc_p->pc & JAPAN_PC_MASK); break; default: /* assuming 24-bit */ g_snprintf(buf, buf_len, "%u", addr_pc_p->pc & ANSI_PC_MASK); break; } break; case MTP3_ADDR_FMT_HEX: switch (addr_pc_p->type) { case ITU_STANDARD: g_snprintf(buf, buf_len, "%x", addr_pc_p->pc & ITU_PC_MASK); break; case JAPAN_STANDARD: g_snprintf(buf, buf_len, "%x", addr_pc_p->pc & JAPAN_PC_MASK); break; default: /* assuming 24-bit */ g_snprintf(buf, buf_len, "%x", addr_pc_p->pc & ANSI_PC_MASK); break; } break; case MTP3_ADDR_FMT_NI_DEC: switch (addr_pc_p->type) { case ITU_STANDARD: g_snprintf(buf, buf_len, "%u:%u", addr_pc_p->ni, addr_pc_p->pc & ITU_PC_MASK); break; case JAPAN_STANDARD: g_snprintf(buf, buf_len, "%u:%u", addr_pc_p->ni, addr_pc_p->pc & JAPAN_PC_MASK); break; default: /* assuming 24-bit */ g_snprintf(buf, buf_len, "%u:%u", addr_pc_p->ni, addr_pc_p->pc & ANSI_PC_MASK); break; } break; case MTP3_ADDR_FMT_NI_HEX: switch (addr_pc_p->type) { case ITU_STANDARD: g_snprintf(buf, buf_len, "%u:%x", addr_pc_p->ni, addr_pc_p->pc & ITU_PC_MASK); break; case JAPAN_STANDARD: g_snprintf(buf, buf_len, "%u:%x", addr_pc_p->ni, addr_pc_p->pc & JAPAN_PC_MASK); break; default: /* assuming 24-bit */ g_snprintf(buf, buf_len, "%u:%x", addr_pc_p->ni, addr_pc_p->pc & ANSI_PC_MASK); break; } break; default: /* FALLTHRU */ case MTP3_ADDR_FMT_DASHED: mtp3_pc_to_str_buf(addr_pc_p->pc, buf, buf_len); break; } }
static const char * cf_open_error_message(int err, gchar *err_info, gboolean for_writing, int file_type) { const char *errmsg; static char errmsg_errno[1024+1]; if (err < 0) { /* Wiretap error. */ switch (err) { case WTAP_ERR_NOT_REGULAR_FILE: errmsg = "The file \"%s\" is a \"special file\" or socket or other non-regular file."; break; case WTAP_ERR_FILE_UNKNOWN_FORMAT: /* Seen only when opening a capture file for reading. */ errmsg = "The file \"%s\" isn't a capture file in a format TShark understands."; break; case WTAP_ERR_UNSUPPORTED: /* Seen only when opening a capture file for reading. */ g_snprintf(errmsg_errno, sizeof(errmsg_errno), "The file \"%%s\" isn't a capture file in a format TShark understands.\n" "(%s)", err_info); g_free(err_info); errmsg = errmsg_errno; break; case WTAP_ERR_CANT_WRITE_TO_PIPE: /* Seen only when opening a capture file for writing. */ g_snprintf(errmsg_errno, sizeof(errmsg_errno), "The file \"%%s\" is a pipe, and %s capture files can't be " "written to a pipe.", wtap_file_type_subtype_string(file_type)); errmsg = errmsg_errno; break; case WTAP_ERR_UNSUPPORTED_FILE_TYPE: /* Seen only when opening a capture file for writing. */ errmsg = "TShark doesn't support writing capture files in that format."; break; case WTAP_ERR_UNSUPPORTED_ENCAP: if (for_writing) errmsg = "TShark can't save this capture in that format."; else { g_snprintf(errmsg_errno, sizeof(errmsg_errno), "The file \"%%s\" is a capture for a network type that TShark doesn't support.\n" "(%s)", err_info); g_free(err_info); errmsg = errmsg_errno; } break; case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED: if (for_writing) errmsg = "TShark can't save this capture in that format."; else errmsg = "The file \"%s\" is a capture for a network type that TShark doesn't support."; break; case WTAP_ERR_BAD_FILE: /* Seen only when opening a capture file for reading. */ g_snprintf(errmsg_errno, sizeof(errmsg_errno), "The file \"%%s\" appears to be damaged or corrupt.\n" "(%s)", err_info); g_free(err_info); errmsg = errmsg_errno; break; case WTAP_ERR_CANT_OPEN: if (for_writing) errmsg = "The file \"%s\" could not be created for some unknown reason."; else errmsg = "The file \"%s\" could not be opened for some unknown reason."; break; case WTAP_ERR_SHORT_READ: errmsg = "The file \"%s\" appears to have been cut short" " in the middle of a packet or other data."; break; case WTAP_ERR_SHORT_WRITE: errmsg = "A full header couldn't be written to the file \"%s\"."; break; case WTAP_ERR_DECOMPRESS: g_snprintf(errmsg_errno, sizeof(errmsg_errno), "The compressed file \"%%s\" appears to be damaged or corrupt.\n" "(%s)", err_info); g_free(err_info); errmsg = errmsg_errno; break; default: g_snprintf(errmsg_errno, sizeof(errmsg_errno), "The file \"%%s\" could not be %s: %s.", for_writing ? "created" : "opened", wtap_strerror(err)); errmsg = errmsg_errno; break; } } else errmsg = file_open_error_message(err, for_writing); return errmsg; }
static void eth_prompt(packet_info *pinfo, gchar* result) { g_snprintf(result, MAX_DECODE_AS_PROMPT_LEN, "Ethertype 0x%04x as", GPOINTER_TO_UINT(p_get_proto_data(pinfo->pool, pinfo, proto_ethertype, 0))); }
void GetDBParams(void) { Field_T port_string, sock_string, serverid_string, query_time; Field_T max_db_connections; if (config_get_value("driver", "DBMAIL", db_params.driver) < 0) TRACE(TRACE_EMERG, "error getting config! [driver]"); if (MATCH((const char *)db_params.driver,"sqlite")) db_params.db_driver = DM_DRIVER_SQLITE; else if (MATCH((const char *)db_params.driver,"mysql")) db_params.db_driver = DM_DRIVER_MYSQL; else if (MATCH((const char *)db_params.driver,"postgresql")) db_params.db_driver = DM_DRIVER_POSTGRESQL; else if (MATCH((const char *)db_params.driver,"oracle")) db_params.db_driver = DM_DRIVER_ORACLE; else TRACE(TRACE_EMERG,"driver not supported"); if (config_get_value("authdriver", "DBMAIL", db_params.authdriver) < 0) TRACE(TRACE_EMERG, "error getting config! [authdriver]"); if (config_get_value("sortdriver", "DBMAIL", db_params.sortdriver) < 0) TRACE(TRACE_EMERG, "error getting config! [sortdriver]"); if (config_get_value("host", "DBMAIL", db_params.host) < 0) TRACE(TRACE_EMERG, "error getting config! [host]"); if (config_get_value("db", "DBMAIL", db_params.db) < 0) TRACE(TRACE_EMERG, "error getting config! [db]"); if (config_get_value("user", "DBMAIL", db_params.user) < 0) TRACE(TRACE_EMERG, "error getting config! [user]"); if (config_get_value("pass", "DBMAIL", db_params.pass) < 0) TRACE(TRACE_EMERG, "error getting config! [pass]"); if (config_get_value("sqlport", "DBMAIL", port_string) < 0) TRACE(TRACE_EMERG, "error getting config! [sqlpost]"); if (config_get_value("sqlsocket", "DBMAIL", sock_string) < 0) TRACE(TRACE_EMERG, "error getting config! [sqlsocket]"); if (config_get_value("serverid", "DBMAIL", serverid_string) < 0) TRACE(TRACE_EMERG, "error getting config! [serverid]"); if (config_get_value("encoding", "DBMAIL", db_params.encoding) < 0) TRACE(TRACE_EMERG, "error getting config! [encoding]"); if (config_get_value("table_prefix", "DBMAIL", db_params.pfx) < 0) TRACE(TRACE_EMERG, "error getting config! [table_prefix]"); if (config_get_value("max_db_connections", "DBMAIL", max_db_connections) < 0) TRACE(TRACE_EMERG, "error getting config! [max_db_connections]"); if (config_get_value("query_time_info", "DBMAIL", query_time) < 0) TRACE(TRACE_EMERG, "error getting config! [query_time_info]"); if (strlen(query_time) != 0) db_params.query_time_info = (unsigned int) strtoul(query_time, NULL, 10); else db_params.query_time_info = 10; if (config_get_value("query_time_notice", "DBMAIL", query_time) < 0) TRACE(TRACE_EMERG, "error getting config! [query_time_notice]"); if (strlen(query_time) != 0) db_params.query_time_notice = (unsigned int) strtoul(query_time, NULL, 10); else db_params.query_time_notice = 20; if (config_get_value("query_time_warning", "DBMAIL", query_time) < 0) TRACE(TRACE_EMERG, "error getting config! [query_time_warning]"); if (strlen(query_time) != 0) db_params.query_time_warning = (unsigned int) strtoul(query_time, NULL, 10); else db_params.query_time_warning = 30; if (config_get_value("query_timeout", "DBMAIL", query_time) < 0) TRACE(TRACE_EMERG, "error getting config! [query_timeout]"); if (strlen(query_time) != 0) db_params.query_timeout = (unsigned int) strtoul(query_time, NULL, 10) * 1000; else db_params.query_timeout = 300000; if (strcmp(db_params.pfx, "\"\"") == 0) { /* FIXME: It appears that when the empty string is quoted * that the quotes themselves are returned as the value. */ g_strlcpy(db_params.pfx, "", FIELDSIZE); } else if (strlen(db_params.pfx) == 0) { /* If it's not "" but is zero length, set the default. */ g_strlcpy(db_params.pfx, DEFAULT_DBPFX, FIELDSIZE); } /* expand ~ in db name to HOME env variable */ if ((strlen(db_params.db) > 0 ) && (db_params.db[0] == '~')) { char *homedir; Field_T db; if ((homedir = getenv ("HOME")) == NULL) TRACE(TRACE_EMERG, "can't expand ~ in db name"); g_snprintf(db, FIELDSIZE, "%s%s", homedir, &(db_params.db[1])); g_strlcpy(db_params.db, db, FIELDSIZE); } /* check if port_string holds a value */ if (strlen(port_string) != 0) { errno = 0; db_params.port = (unsigned int) strtoul(port_string, NULL, 10); if (errno == EINVAL || errno == ERANGE) TRACE(TRACE_EMERG, "wrong value for sqlport in config file [%s]", strerror(errno)); } else db_params.port = 0; /* same for sock_string */ if (strlen(sock_string) != 0) g_strlcpy(db_params.sock, sock_string, FIELDSIZE); else db_params.sock[0] = '\0'; /* serverid */ if (strlen(serverid_string) != 0) { db_params.serverid = (unsigned int) strtol(serverid_string, NULL, 10); if (errno == EINVAL || errno == ERANGE) TRACE(TRACE_EMERG, "serverid invalid in config file"); } else { db_params.serverid = 1; } /* max_db_connections */ if (strlen(max_db_connections) != 0) { db_params.max_db_connections = (unsigned int) strtol(max_db_connections, NULL, 10); if (errno == EINVAL || errno == ERANGE) TRACE(TRACE_EMERG, "max_db_connnections invalid in config file"); } else { db_params.max_db_connections = 10; } }
/* Transport implementation */ int janus_websockets_init(janus_transport_callbacks *callback, const char *config_path) { if(g_atomic_int_get(&stopping)) { /* Still stopping from before */ return -1; } if(callback == NULL || config_path == NULL) { /* Invalid arguments */ return -1; } /* This is the callback we'll need to invoke to contact the gateway */ gateway = callback; /* Read configuration */ char filename[255]; g_snprintf(filename, 255, "%s/%s.cfg", config_path, JANUS_WEBSOCKETS_PACKAGE); JANUS_LOG(LOG_VERB, "Configuration file: %s\n", filename); janus_config *config = janus_config_parse(filename); if(config != NULL) { janus_config_print(config); /* Handle configuration */ janus_config_item *item = janus_config_get_item_drilldown(config, "general", "ws_logging"); if(item && item->value) { ws_log_level = atoi(item->value); if(ws_log_level < 0) ws_log_level = 0; } JANUS_LOG(LOG_VERB, "libwebsockets logging: %d\n", ws_log_level); lws_set_log_level(ws_log_level, NULL); old_wss = NULL; janus_mutex_init(&old_wss_mutex); /* Any ACL for either the Janus or Admin API? */ item = janus_config_get_item_drilldown(config, "general", "ws_acl"); if(item && item->value) { gchar **list = g_strsplit(item->value, ",", -1); gchar *index = list[0]; if(index != NULL) { int i=0; while(index != NULL) { if(strlen(index) > 0) { JANUS_LOG(LOG_INFO, "Adding '%s' to the Janus API allowed list...\n", index); janus_websockets_allow_address(g_strdup(index), FALSE); } i++; index = list[i]; } } g_strfreev(list); list = NULL; } item = janus_config_get_item_drilldown(config, "admin", "admin_ws_acl"); if(item && item->value) { gchar **list = g_strsplit(item->value, ",", -1); gchar *index = list[0]; if(index != NULL) { int i=0; while(index != NULL) { if(strlen(index) > 0) { JANUS_LOG(LOG_INFO, "Adding '%s' to the Admin/monitor allowed list...\n", index); janus_websockets_allow_address(g_strdup(index), TRUE); } i++; index = list[i]; } } g_strfreev(list); list = NULL; } /* Setup the Janus API WebSockets server(s) */ item = janus_config_get_item_drilldown(config, "general", "ws"); if(!item || !item->value || !janus_is_true(item->value)) { JANUS_LOG(LOG_WARN, "WebSockets server disabled\n"); } else { int wsport = 8188; item = janus_config_get_item_drilldown(config, "general", "ws_port"); if(item && item->value) wsport = atoi(item->value); /* Prepare context */ struct lws_context_creation_info info; memset(&info, 0, sizeof info); info.port = wsport; info.iface = NULL; info.protocols = wss_protocols; info.extensions = libwebsocket_get_internal_extensions(); info.ssl_cert_filepath = NULL; info.ssl_private_key_filepath = NULL; info.gid = -1; info.uid = -1; info.options = 0; /* Create the WebSocket context */ wss = libwebsocket_create_context(&info); if(wss == NULL) { JANUS_LOG(LOG_FATAL, "Error initializing libwebsock...\n"); } else { JANUS_LOG(LOG_INFO, "WebSockets server started (port %d)...\n", wsport); } } item = janus_config_get_item_drilldown(config, "general", "wss"); if(!item || !item->value || !janus_is_true(item->value)) { JANUS_LOG(LOG_WARN, "Secure WebSockets server disabled\n"); } else { int wsport = 8989; item = janus_config_get_item_drilldown(config, "general", "wss_port"); if(item && item->value) wsport = atoi(item->value); item = janus_config_get_item_drilldown(config, "certificates", "cert_pem"); if(!item || !item->value) { JANUS_LOG(LOG_FATAL, "Missing certificate/key path\n"); } else { char *server_pem = (char *)item->value; char *server_key = (char *)item->value; item = janus_config_get_item_drilldown(config, "certificates", "cert_key"); if(item && item->value) server_key = (char *)item->value; JANUS_LOG(LOG_VERB, "Using certificates:\n\t%s\n\t%s\n", server_pem, server_key); /* Prepare secure context */ struct lws_context_creation_info info; memset(&info, 0, sizeof info); info.port = wsport; info.iface = NULL; info.protocols = swss_protocols; info.extensions = libwebsocket_get_internal_extensions(); info.ssl_cert_filepath = server_pem; info.ssl_private_key_filepath = server_key; info.gid = -1; info.uid = -1; info.options = 0; /* Create the secure WebSocket context */ swss = libwebsocket_create_context(&info); if(swss == NULL) { JANUS_LOG(LOG_FATAL, "Error initializing libwebsock...\n"); } else { JANUS_LOG(LOG_INFO, "Secure WebSockets server started (port %d)...\n", wsport); } } } /* Do the same for the Admin API, if enabled */ item = janus_config_get_item_drilldown(config, "admin", "admin_ws"); if(!item || !item->value || !janus_is_true(item->value)) { JANUS_LOG(LOG_WARN, "Admin WebSockets server disabled\n"); } else { int wsport = 7188; item = janus_config_get_item_drilldown(config, "admin", "admin_ws_port"); if(item && item->value) wsport = atoi(item->value); /* Prepare context */ struct lws_context_creation_info info; memset(&info, 0, sizeof info); info.port = wsport; info.iface = NULL; info.protocols = admin_wss_protocols; info.extensions = libwebsocket_get_internal_extensions(); info.ssl_cert_filepath = NULL; info.ssl_private_key_filepath = NULL; info.gid = -1; info.uid = -1; info.options = 0; /* Create the WebSocket context */ admin_wss = libwebsocket_create_context(&info); if(admin_wss == NULL) { JANUS_LOG(LOG_FATAL, "Error initializing libwebsock...\n"); } else { JANUS_LOG(LOG_INFO, "Admin WebSockets server started (port %d)...\n", wsport); } } item = janus_config_get_item_drilldown(config, "admin", "admin_wss"); if(!item || !item->value || !janus_is_true(item->value)) { JANUS_LOG(LOG_WARN, "Secure Admin WebSockets server disabled\n"); } else { int wsport = 7989; item = janus_config_get_item_drilldown(config, "admin", "admin_wss_port"); if(item && item->value) wsport = atoi(item->value); item = janus_config_get_item_drilldown(config, "certificates", "cert_pem"); if(!item || !item->value) { JANUS_LOG(LOG_FATAL, "Missing certificate/key path\n"); } else { char *server_pem = (char *)item->value; char *server_key = (char *)item->value; item = janus_config_get_item_drilldown(config, "certificates", "cert_key"); if(item && item->value) server_key = (char *)item->value; JANUS_LOG(LOG_VERB, "Using certificates:\n\t%s\n\t%s\n", server_pem, server_key); /* Prepare secure context */ struct lws_context_creation_info info; memset(&info, 0, sizeof info); info.port = wsport; info.iface = NULL; info.protocols = admin_swss_protocols; info.extensions = libwebsocket_get_internal_extensions(); info.ssl_cert_filepath = server_pem; info.ssl_private_key_filepath = server_key; info.gid = -1; info.uid = -1; info.options = 0; /* Create the secure WebSocket context */ admin_swss = libwebsocket_create_context(&info); if(admin_swss == NULL) { JANUS_LOG(LOG_FATAL, "Error initializing libwebsock...\n"); } else { JANUS_LOG(LOG_INFO, "Secure Admin WebSockets server started (port %d)...\n", wsport); } } } } janus_config_destroy(config); config = NULL; if(!wss && !swss && !admin_wss && !admin_swss) { JANUS_LOG(LOG_FATAL, "No WebSockets server started, giving up...\n"); return -1; /* No point in keeping the plugin loaded */ } wss_janus_api_enabled = wss || swss; wss_admin_api_enabled = admin_wss || admin_swss; GError *error = NULL; /* Start the WebSocket service threads */ if(wss != NULL) { wss_thread = g_thread_try_new("websockets thread", &janus_websockets_thread, wss, &error); if(!wss_thread) { g_atomic_int_set(&initialized, 0); JANUS_LOG(LOG_ERR, "Got error %d (%s) trying to launch the WebSockets thread...\n", error->code, error->message ? error->message : "??"); return -1; } } if(swss != NULL) { swss_thread = g_thread_try_new("secure websockets thread", &janus_websockets_thread, swss, &error); if(!swss_thread) { g_atomic_int_set(&initialized, 0); JANUS_LOG(LOG_ERR, "Got error %d (%s) trying to launch the Secure WebSockets thread...\n", error->code, error->message ? error->message : "??"); return -1; } } if(admin_wss != NULL) { admin_wss_thread = g_thread_try_new("admin websockets thread", &janus_websockets_thread, admin_wss, &error); if(!admin_wss_thread) { g_atomic_int_set(&initialized, 0); JANUS_LOG(LOG_ERR, "Got error %d (%s) trying to launch the Admin WebSockets thread...\n", error->code, error->message ? error->message : "??"); return -1; } } if(admin_swss != NULL) { admin_swss_thread = g_thread_try_new("secure admin websockets thread", &janus_websockets_thread, admin_swss, &error); if(!admin_swss_thread) { g_atomic_int_set(&initialized, 0); JANUS_LOG(LOG_ERR, "Got error %d (%s) trying to launch the Secure Admin WebSockets thread...\n", error->code, error->message ? error->message : "??"); return -1; } } /* Done */ g_atomic_int_set(&initialized, 1); JANUS_LOG(LOG_INFO, "%s initialized!\n", JANUS_WEBSOCKETS_NAME); return 0; }
static void plugins_scan_dir(const char *dirname) { #define FILENAME_LEN 1024 WS_DIR *dir; /* scanned directory */ WS_DIRENT *file; /* current file */ const char *name; gchar filename[FILENAME_LEN]; /* current file name */ GModule *handle; /* handle returned by g_module_open */ gpointer gp; plugin *new_plug; gchar *dot; int cr; if ((dir = ws_dir_open(dirname, 0, NULL)) != NULL) { while ((file = ws_dir_read_name(dir)) != NULL) { name = ws_dir_get_name(file); /* * GLib 2.x defines G_MODULE_SUFFIX as the extension used on * this platform for loadable modules. */ /* skip anything but files with G_MODULE_SUFFIX */ dot = strrchr(name, '.'); if (dot == NULL || strcmp(dot+1, G_MODULE_SUFFIX) != 0) continue; g_snprintf(filename, FILENAME_LEN, "%s" G_DIR_SEPARATOR_S "%s", dirname, name); if ((handle = g_module_open(filename, G_MODULE_BIND_LOCAL)) == NULL) { report_failure("Couldn't load module %s: %s", filename, g_module_error()); continue; } if (!g_module_symbol(handle, "version", &gp)) { report_failure("The plugin %s has no version symbol", name); g_module_close(handle); continue; } new_plug = (plugin *)g_malloc(sizeof(plugin)); new_plug->handle = handle; new_plug->name = g_strdup(name); new_plug->version = (char *)gp; new_plug->types = 0; new_plug->next = NULL; /* * Hand the plugin to each of the plugin type callbacks. */ g_slist_foreach(plugin_types, call_plugin_callback, new_plug); /* * Does this dissector do anything useful? */ if (new_plug->types == 0) { /* * No. */ report_failure("The plugin '%s' has no registration routines", name); g_module_close(handle); g_free(new_plug->name); g_free(new_plug); continue; } /* * OK, attempt to add it to the list of plugins. */ cr = add_plugin(new_plug); if (cr != 0) { g_assert(cr == EEXIST); fprintf(stderr, "The plugin '%s' version %s " "was found in multiple directories.\n", new_plug->name, new_plug->version); g_module_close(handle); g_free(new_plug->name); g_free(new_plug); continue; } } ws_dir_close(dir); } }
gboolean view_file_at_line (const vfs_path_t * filename_vpath, gboolean plain_view, gboolean internal, long start_line, off_t search_start, off_t search_end) { gboolean ret = TRUE; if (plain_view) { int changed_hex_mode = 0; int changed_nroff_flag = 0; int changed_magic_flag = 0; mcview_altered_hex_mode = 0; mcview_altered_nroff_flag = 0; mcview_altered_magic_flag = 0; if (mcview_default_hex_mode) changed_hex_mode = 1; if (mcview_default_nroff_flag) changed_nroff_flag = 1; if (mcview_default_magic_flag) changed_magic_flag = 1; mcview_default_hex_mode = 0; mcview_default_nroff_flag = 0; mcview_default_magic_flag = 0; ret = mcview_viewer (NULL, filename_vpath, start_line, search_start, search_end); if (changed_hex_mode && !mcview_altered_hex_mode) mcview_default_hex_mode = 1; if (changed_nroff_flag && !mcview_altered_nroff_flag) mcview_default_nroff_flag = 1; if (changed_magic_flag && !mcview_altered_magic_flag) mcview_default_magic_flag = 1; dialog_switch_process_pending (); } else if (internal) { char view_entry[BUF_TINY]; if (start_line > 0) g_snprintf (view_entry, sizeof (view_entry), "View:%ld", start_line); else strcpy (view_entry, "View"); ret = (regex_command (filename_vpath, view_entry) == 0); if (ret) { ret = mcview_viewer (NULL, filename_vpath, start_line, search_start, search_end); dialog_switch_process_pending (); } } else { static const char *viewer = NULL; if (viewer == NULL) { viewer = getenv ("VIEWER"); if (viewer == NULL) viewer = getenv ("PAGER"); if (viewer == NULL) viewer = "view"; } execute_external_editor_or_viewer (viewer, filename_vpath, start_line); } return ret; }
static void prism_rate_base_custom(gchar *result, guint32 rate) { g_snprintf(result, ITEM_LABEL_LENGTH, "%u.%u", rate /2, rate & 1 ? 5 : 0); }
static void qq_chatwidget_init(QQChatWidget *widget) { QQChatWidgetPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE(widget , qq_chatwidget_get_type() , QQChatWidgetPriv); GtkWidget *scrolled_win; gchar buf[100]; // message text view priv -> message_textview = qq_chat_textview_new(); scrolled_win= gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_win) , GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(scrolled_win), priv -> message_textview); gtk_box_pack_start(GTK_BOX(widget), scrolled_win, TRUE, TRUE, 0); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(priv -> message_textview) , FALSE); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(priv -> message_textview) , GTK_WRAP_CHAR); gtk_text_view_set_editable(GTK_TEXT_VIEW(priv -> message_textview) , FALSE); // font tools priv -> font_tool_box = gtk_hbox_new(FALSE, 5); g_object_ref(priv -> font_tool_box); priv -> font_cb = gtk_combo_box_text_new(); gint i; for(i = 0; font_names[i] != NULL; ++i){ gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv -> font_cb) , font_names[i]); } gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> font_cb , FALSE, FALSE, 0); priv -> size_cb = gtk_combo_box_text_new(); for(i = 8; i < 23; ++i){ g_snprintf(buf, 10, "%d", i); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv -> size_cb) , buf); } gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> size_cb , FALSE, FALSE, 0); priv -> bold_btn = qq_toggle_button_new_with_stock(GTK_STOCK_BOLD); priv -> italic_btn = qq_toggle_button_new_with_stock(GTK_STOCK_ITALIC); priv -> underline_btn = qq_toggle_button_new_with_stock( GTK_STOCK_UNDERLINE); gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> bold_btn , FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> italic_btn , FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> underline_btn , FALSE, FALSE, 0); priv -> color_btn = gtk_color_button_new(); gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> color_btn , FALSE, FALSE, 0); gtk_widget_show_all(priv -> font_tool_box); g_signal_connect(G_OBJECT(priv -> font_cb), "changed" , G_CALLBACK(qq_chat_widget_font_changed), widget); g_signal_connect(G_OBJECT(priv -> size_cb), "changed" , G_CALLBACK(qq_chat_widget_font_changed), widget); g_signal_connect(G_OBJECT(priv -> bold_btn), "toggled" , G_CALLBACK(qq_chat_widget_font_changed), widget); g_signal_connect(G_OBJECT(priv -> italic_btn), "toggled" , G_CALLBACK(qq_chat_widget_font_changed), widget); g_signal_connect(G_OBJECT(priv -> underline_btn), "toggled" , G_CALLBACK(qq_chat_widget_font_changed), widget); g_signal_connect(G_OBJECT(priv -> color_btn), "color-set" , G_CALLBACK(qq_chat_widget_font_changed), widget); // tool bar priv -> tool_bar = gtk_toolbar_new(); GtkWidget *img = NULL; img = gtk_image_new_from_file(IMGDIR"/selectfont.png"); priv -> font_item = gtk_toggle_tool_button_new(); g_signal_connect(G_OBJECT(priv -> font_item), "toggled" , G_CALLBACK(qq_chat_view_font_button_clicked) , widget); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(priv -> font_item), img); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> font_item, -1); img = gtk_image_new_from_file(IMGDIR"/selectface.png"); priv -> face_item = gtk_tool_button_new(img, NULL); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> face_item, -1); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar) , gtk_separator_tool_item_new() , -1); g_signal_connect(G_OBJECT(priv -> face_item), "clicked", G_CALLBACK(face_tool_button_clicked), widget); img = gtk_image_new_from_file(IMGDIR"/sendfile.png"); priv -> sendfile_item = gtk_tool_button_new(img, NULL); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> sendfile_item, -1); img = gtk_image_new_from_file(IMGDIR"/sendpic.png"); priv -> sendpic_item = gtk_tool_button_new(img, NULL); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> sendpic_item, -1); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar) , gtk_separator_tool_item_new() , -1); img = gtk_image_new_from_file(IMGDIR"/clearscreen.png"); priv -> clear_item = gtk_tool_button_new(img, NULL); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> clear_item, -1); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar) , gtk_separator_tool_item_new() , -1); g_signal_connect(G_OBJECT(priv -> clear_item), "clicked", G_CALLBACK(clear_button_clicked), widget); img = gtk_image_new_from_file(IMGDIR"/showhistory.png"); priv -> history_item = gtk_tool_button_new(img, NULL); gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> history_item, -1); gtk_box_pack_start(GTK_BOX(widget), priv -> tool_bar , FALSE, FALSE, 0); // input text view priv -> input_textview = qq_chat_textview_new(); gtk_text_view_set_indent(GTK_TEXT_VIEW(priv -> input_textview), 1); scrolled_win= gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_win) , GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(scrolled_win), priv -> input_textview); gtk_box_pack_start(GTK_BOX(widget), scrolled_win, FALSE, FALSE, 0); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(priv -> input_textview) , GTK_WRAP_CHAR); gtk_combo_box_set_active(GTK_COMBO_BOX(priv -> font_cb), 1); gtk_combo_box_set_active(GTK_COMBO_BOX(priv -> size_cb), 3); gtk_widget_grab_focus(priv -> input_textview); priv -> facepopupwindow = qq_face_popup_window_new(); g_signal_connect(G_OBJECT(priv -> facepopupwindow), "face-clicked" , G_CALLBACK(qq_chatwidget_face_clicked) , priv); }
static void dt_film_import1(dt_job_t *job, dt_film_t *film) { gboolean recursive = dt_conf_get_bool("ui_last/import_recursive"); /* first of all gather all images to import */ GList *images = NULL; images = _film_recursive_get_files(film->dirname, recursive, &images); if(g_list_length(images) == 0) { dt_control_log(_("no supported images were found to be imported")); return; } #ifdef USE_LUA /* pre-sort image list for easier handling in Lua code */ images = g_list_sort(images, (GCompareFunc)_film_filename_cmp); dt_lua_lock(); lua_State *L = darktable.lua_state.state; { GList *elt = images; lua_newtable(L); while(elt) { lua_pushstring(L, elt->data); luaL_ref(L, -2); elt = g_list_next(elt); } } lua_pushvalue(L, -1); dt_lua_event_trigger(L, "pre-import", 1); { g_list_free_full(images, g_free); // recreate list of images images = NULL; lua_pushnil(L); /* first key */ while(lua_next(L, -2) != 0) { /* uses 'key' (at index -2) and 'value' (at index -1) */ void *filename = strdup(luaL_checkstring(L, -1)); lua_pop(L, 1); images = g_list_prepend(images, filename); } } lua_pop(L, 1); // remove the table again from the stack dt_lua_unlock(); #endif if(g_list_length(images) == 0) { // no error message, lua probably emptied the list on purpose return; } /* we got ourself a list of images, lets sort and start import */ images = g_list_sort(images, (GCompareFunc)_film_filename_cmp); /* let's start import of images */ gchar message[512] = { 0 }; double fraction = 0; guint total = g_list_length(images); g_snprintf(message, sizeof(message) - 1, ngettext("importing %d image", "importing %d images", total), total); dt_control_job_set_progress_message(job, message); /* loop thru the images and import to current film roll */ dt_film_t *cfr = film; GList *image = g_list_first(images); do { gchar *cdn = g_path_get_dirname((const gchar *)image->data); /* check if we need to initialize a new filmroll */ if(!cfr || g_strcmp0(cfr->dirname, cdn) != 0) { // FIXME: maybe refactor into function and call it? if(cfr && cfr->dir) { /* check if we can find a gpx data file to be auto applied to images in the jsut imported filmroll */ g_dir_rewind(cfr->dir); const gchar *dfn = NULL; while((dfn = g_dir_read_name(cfr->dir)) != NULL) { /* check if we have a gpx to be auto applied to filmroll */ size_t len = strlen(dfn); if(strcmp(dfn + len - 4, ".gpx") == 0 || strcmp(dfn + len - 4, ".GPX") == 0) { gchar *gpx_file = g_build_path(G_DIR_SEPARATOR_S, cfr->dirname, dfn, NULL); gchar *tz = dt_conf_get_string("plugins/lighttable/geotagging/tz"); dt_control_gpx_apply(gpx_file, cfr->id, tz); g_free(gpx_file); g_free(tz); } } } /* cleanup previously imported filmroll*/ if(cfr && cfr != film) { if(dt_film_is_empty(cfr->id)) { dt_film_remove(cfr->id); } dt_film_cleanup(cfr); free(cfr); cfr = NULL; } /* initialize and create a new film to import to */ cfr = malloc(sizeof(dt_film_t)); dt_film_init(cfr); dt_film_new(cfr, cdn); } g_free(cdn); /* import image */ dt_image_import(cfr->id, (const gchar *)image->data, FALSE); fraction += 1.0 / total; dt_control_job_set_progress(job, fraction); } while((image = g_list_next(image)) != NULL); g_list_free_full(images, g_free); // only redraw at the end, to not spam the cpu with exposure events dt_control_queue_redraw_center(); dt_control_signal_raise(darktable.signals, DT_SIGNAL_TAG_CHANGED); dt_control_signal_raise(darktable.signals, DT_SIGNAL_FILMROLLS_IMPORTED, film->id); // FIXME: maybe refactor into function and call it? if(cfr && cfr->dir) { /* check if we can find a gpx data file to be auto applied to images in the just imported filmroll */ g_dir_rewind(cfr->dir); const gchar *dfn = NULL; while((dfn = g_dir_read_name(cfr->dir)) != NULL) { /* check if we have a gpx to be auto applied to filmroll */ size_t len = strlen(dfn); if(strcmp(dfn + len - 4, ".gpx") == 0 || strcmp(dfn + len - 4, ".GPX") == 0) { gchar *gpx_file = g_build_path(G_DIR_SEPARATOR_S, cfr->dirname, dfn, NULL); gchar *tz = dt_conf_get_string("plugins/lighttable/geotagging/tz"); dt_control_gpx_apply(gpx_file, cfr->id, tz); g_free(gpx_file); g_free(tz); } } } /* cleanup previously imported filmroll*/ if(cfr && cfr != film) { dt_film_cleanup(cfr); free(cfr); } }
static int send_flash (CalcHandle* handle, FlashContent* content) { FlashContent *ptr; int i; char *utf8; CalcAttr **attrs; const int nattrs = 2; uint8_t *data; uint32_t size; // search for data header for (ptr = content; ptr != NULL; ptr = ptr->next) if(ptr->data_type == TI83p_AMS || ptr->data_type == TI83p_APPL) break; if(ptr == NULL) return -1; if(ptr->data_type != TI83p_APPL) return -1; #if 0 printf("#pages: %i\n", ptr->num_pages); printf("type: %02x\n", ptr->data_type); for (i = 0; i < ptr->num_pages; i++) { FlashPage *fp = ptr->pages[i]; printf("page #%i: %04x %02x %02x %04x\n", i, fp->addr, fp->page, fp->flag, fp->size); } printf("data length: %08x\n", ptr->data_length); return 0; #endif size = ptr->num_pages * FLASH_PAGE_SIZE; data = tifiles_fp_alloc_data(size); // must be rounded-up update_->cnt2 = 0; update_->max2 = ptr->num_pages; for (i = 0; i < ptr->num_pages; i++) { FlashPage *fp = ptr->pages[i]; memcpy(data + i*FLASH_PAGE_SIZE, fp->data, FLASH_PAGE_SIZE); update_->cnt2 = i; update_->pbar(); } { FlashPage *fp = ptr->pages[--i]; memset(data + i*FLASH_PAGE_SIZE + fp->size, 0x00, FLASH_PAGE_SIZE - fp->size); update_->cnt2 = i; update_->pbar(); } // send utf8 = ticonv_varname_to_utf8(handle->model, ptr->name, ptr->data_type); g_snprintf(update_->text, sizeof(update_->text), "%s", utf8); g_free(utf8); update_label(); attrs = ca_new_array(nattrs); attrs[0] = ca_new(AID_VAR_TYPE, 4); attrs[0]->data[0] = 0xF0; attrs[0]->data[1] = 0x07; attrs[0]->data[2] = 0x00; attrs[0]->data[3] = ptr->data_type; attrs[1] = ca_new(AID_ARCHIVED, 1); attrs[1]->data[0] = 0; TRYF(cmd_s_rts(handle, "", ptr->name, size, nattrs, CA(attrs))); TRYF(cmd_r_data_ack(handle)); TRYF(cmd_s_var_content(handle, size, data)); TRYF(cmd_r_data_ack(handle)); TRYF(cmd_s_eot(handle)); return 0; }
int set_gtk_list_item(st_gtk_list_item *gtk_list_item) { if (list_length + 1 < MAX_LIST_ENTRIES) { list[list_length].is_birthday = (strcmp(gtk_list_item->type, phrases_data.option_type_birthday) == 0) ? 1 : 0; list[list_length].repeat_cycle = gtk_list_item->cycle; strcpy(list[list_length].text, gtk_list_item->text); if (strlen(list[list_length].text) == 0) return -1; // not enough text data char *ptr; ptr = strtok(gtk_list_item->date, "."); int i = 0; while (ptr != NULL) { switch (i) { case 0: list[list_length].date.day = atoi(ptr); break; case 1: list[list_length].date.month = atoi(ptr); break; case 2: list[list_length].date.year = atoi(ptr); break; } ptr = strtok(NULL, "."); i++; } if (i != 3) return -1; // not enough date data ptr = strtok(gtk_list_item->time, ":"); i = 0; while (ptr != NULL) { switch (i) { case 0: list[list_length].time.hour = atoi(ptr); break; case 1: list[list_length].time.minute = atoi(ptr); break; } ptr = strtok(NULL, ":"); i++; } if (i != 2) return -1; // not enough time data list[list_length].next_event_time = calculate_next_event_time(&list[list_length]); if (list[list_length].next_event_time == -1) return -1; // no next event time available // set next event time to gtk item g_snprintf(gtk_list_item->date, 256, "%s%d.%s%d.%d", (list[list_length].date.day < 10) ? "0" : "", list[list_length].date.day, (list[list_length].date.month < 10) ? "0" : "", list[list_length].date.month, list[list_length].date.year); g_snprintf(gtk_list_item->time, 256, "%s%d:%s%d", (list[list_length].time.hour < 10) ? "0" : "", list[list_length].time.hour, (list[list_length].time.minute < 10) ? "0" : "", list[list_length].time.minute); list[list_length].last_notification_time = -1; list_length++; i = list_find_next_idx(&list[list_length-1]); list_sort(); return i; } return -1; // max items count reached }
static int set_clock (CalcHandle* handle, CalcClock* _clock) { CalcParam *param; uint32_t calc_time; struct tm ref, cur; time_t r, c, now; time(&now); memcpy(&ref, localtime(&now), sizeof(struct tm)); ref.tm_year = 1997 - 1900; ref.tm_mon = 0; ref.tm_yday = 0; ref.tm_mday = 1; ref.tm_wday = 3; ref.tm_hour = 0; ref.tm_min = 0; ref.tm_sec = 0; //ref.tm_isdst = 1; r = mktime(&ref); cur.tm_year = _clock->year - 1900; cur.tm_mon = _clock->month - 1; cur.tm_mday = _clock->day; cur.tm_hour = _clock->hours; cur.tm_min = _clock->minutes; cur.tm_sec = _clock->seconds; cur.tm_isdst = 1; c = mktime(&cur); calc_time = (uint32_t)difftime(c, r); g_snprintf(update_->text, sizeof(update_->text), _("Setting clock...")); update_label(); param = cp_new(PID_CLK_SEC, 4); param->data[0] = MSB(MSW(calc_time)); param->data[1] = LSB(MSW(calc_time)); param->data[2] = MSB(LSW(calc_time)); param->data[3] = LSB(LSW(calc_time)); TRYF(cmd_s_param_set(handle, param)); TRYF(cmd_r_data_ack(handle)); cp_del(param); param = cp_new(PID_CLK_DATE_FMT, 1); param->data[0] = _clock->date_format == 3 ? 0 : _clock->date_format; TRYF(cmd_s_param_set(handle, param)); TRYF(cmd_r_data_ack(handle)); cp_del(param); param = cp_new(PID_CLK_TIME_FMT, 1); param->data[0] = _clock->time_format == 24 ? 1 : 0; TRYF(cmd_s_param_set(handle, param)); TRYF(cmd_r_data_ack(handle)); cp_del(param); param = cp_new(PID_CLK_ON, 1); param->data[0] = _clock->state; TRYF(cmd_s_param_set(handle, param)); TRYF(cmd_r_data_ack(handle)); cp_del(param); return 0; }
static gchar * absolute_time_string(nstime_t *timer, int tsprecision, capture_info *cf_info) { static gchar time_string_buf[4+1+2+1+2+1+2+1+2+1+2+1+9+1+1]; struct tm *ti_tm; if (cf_info->times_known && cf_info->packet_count > 0) { if (time_as_secs) { switch (tsprecision) { case WTAP_TSPREC_SEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%lu", (unsigned long)timer->secs); break; case WTAP_TSPREC_DSEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%lu.%01d", (unsigned long)timer->secs, timer->nsecs / 100000000); break; case WTAP_TSPREC_CSEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%lu.%02d", (unsigned long)timer->secs, timer->nsecs / 10000000); break; case WTAP_TSPREC_MSEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%lu.%03d", (unsigned long)timer->secs, timer->nsecs / 1000000); break; case WTAP_TSPREC_USEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%lu.%06d", (unsigned long)timer->secs, timer->nsecs / 1000); break; case WTAP_TSPREC_NSEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%lu.%09d", (unsigned long)timer->secs, timer->nsecs); break; default: g_snprintf(time_string_buf, sizeof time_string_buf, "Unknown precision %d", tsprecision); break; } return time_string_buf; } else { ti_tm = localtime(&timer->secs); if (ti_tm == NULL) { g_snprintf(time_string_buf, sizeof time_string_buf, "Not representable"); return time_string_buf; } switch (tsprecision) { case WTAP_TSPREC_SEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%04d-%02d-%02d %02d:%02d:%02d", ti_tm->tm_year + 1900, ti_tm->tm_mon + 1, ti_tm->tm_mday, ti_tm->tm_hour, ti_tm->tm_min, ti_tm->tm_sec); break; case WTAP_TSPREC_DSEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%04d-%02d-%02d %02d:%02d:%02d.%01d", ti_tm->tm_year + 1900, ti_tm->tm_mon + 1, ti_tm->tm_mday, ti_tm->tm_hour, ti_tm->tm_min, ti_tm->tm_sec, timer->nsecs / 100000000); break; case WTAP_TSPREC_CSEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%04d-%02d-%02d %02d:%02d:%02d.%02d", ti_tm->tm_year + 1900, ti_tm->tm_mon + 1, ti_tm->tm_mday, ti_tm->tm_hour, ti_tm->tm_min, ti_tm->tm_sec, timer->nsecs / 10000000); break; case WTAP_TSPREC_MSEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%04d-%02d-%02d %02d:%02d:%02d.%03d", ti_tm->tm_year + 1900, ti_tm->tm_mon + 1, ti_tm->tm_mday, ti_tm->tm_hour, ti_tm->tm_min, ti_tm->tm_sec, timer->nsecs / 1000000); break; case WTAP_TSPREC_USEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%04d-%02d-%02d %02d:%02d:%02d.%06d", ti_tm->tm_year + 1900, ti_tm->tm_mon + 1, ti_tm->tm_mday, ti_tm->tm_hour, ti_tm->tm_min, ti_tm->tm_sec, timer->nsecs / 1000); break; case WTAP_TSPREC_NSEC: g_snprintf(time_string_buf, sizeof time_string_buf, "%04d-%02d-%02d %02d:%02d:%02d.%09d", ti_tm->tm_year + 1900, ti_tm->tm_mon + 1, ti_tm->tm_mday, ti_tm->tm_hour, ti_tm->tm_min, ti_tm->tm_sec, timer->nsecs); break; default: g_snprintf(time_string_buf, sizeof time_string_buf, "Unknown precision %d", tsprecision); break; } return time_string_buf; } } g_snprintf(time_string_buf, sizeof time_string_buf, "n/a"); return time_string_buf; }