static int step1 (pixma_t * s) { int error, tmo; error = activate (s, 0); if (error < 0) return error; error = query_status (s); if (error < 0) return error; if (s->param->source == PIXMA_SOURCE_ADF && !has_paper (s)) return PIXMA_ENO_PAPER; error = activate_cs (s, 0); /*SIM*/ if (error < 0) return error; error = activate_cs (s, 0x20); if (error < 0) return error; tmo = 60; error = calibrate_cs (s); while (error == PIXMA_EBUSY && --tmo >= 0) { if (s->cancel) return PIXMA_ECANCELED; PDBG (pixma_dbg (2, "Scanner is busy. Timed out in %d sec.\n", tmo + 1)); pixma_sleep (1000000); error = calibrate_cs (s); } return error; }
static int handle_interrupt (pixma_t * s, int timeout) { int error; uint8_t intr[16]; error = pixma_wait_interrupt (s->io, intr, sizeof (intr), timeout); if (error == PIXMA_ETIMEDOUT) return 0; if (error < 0) return error; if (error != 16) { PDBG (pixma_dbg (1, "WARNING: unexpected interrupt packet length %d\n", error)); return PIXMA_EPROTO; } if (intr[10] & 0x40) send_time (s); if (intr[12] & 0x40) query_status (s); if (intr[15] & 1) s->events = PIXMA_EV_BUTTON2; /* b/w scan */ if (intr[15] & 2) s->events = PIXMA_EV_BUTTON1; /* color scan */ return 1; }
static void mp730_finish_scan (pixma_t * s) { int error, aborted = 0; mp730_t *mp = (mp730_t *) s->subdriver; switch (mp->state) { case state_transfering: drain_bulk_in (s); /* fall through */ case state_scanning: case state_warmup: aborted = 1; error = abort_session (s); if (error < 0) PDBG (pixma_dbg (1, "WARNING:abort_session() failed %s\n", pixma_strerror (error))); /* fall through */ case state_finished: query_status (s); query_status (s); activate (s, 0); if (! aborted && s->cfg->pid == IR1020_PID) { error = abort_session (s); if (error < 0) { PDBG (pixma_dbg (1, "WARNING:abort_session() failed %s\n", pixma_strerror (error))); query_status (s); query_status (s); activate (s, 0); } } mp->buf = mp->lbuf = mp->imgbuf = NULL; mp->state = state_idle; /* fall through */ case state_idle: break; } }
static void mp750_finish_scan (pixma_t * s) { int error; mp750_t *mp = (mp750_t *) s->subdriver; switch (mp->state) { case state_transfering: drain_bulk_in (s); /* fall through */ case state_scanning: case state_warmup: error = abort_session (s); if (error == PIXMA_ECANCELED) read_error_info (s, NULL, 0); /* fall through */ case state_finished: if (s->param->source == PIXMA_SOURCE_FLATBED) { /*SIM*/ query_status (s); if (abort_session (s) == PIXMA_ECANCELED) { read_error_info (s, NULL, 0); query_status (s); } } query_status (s); /*SIM*/ activate (s, 0); if (mp->needs_abort) { mp->needs_abort = 0; abort_session (s); } free (mp->buf); mp->buf = mp->rawimg = NULL; mp->state = state_idle; /* fall through */ case state_idle: break; } }
static void iclass_finish_scan (pixma_t * s) { int error; iclass_t *mf = (iclass_t *) s->subdriver; switch (mf->state) { /* fall through */ case state_warmup: case state_scanning: error = abort_session (s); if (error < 0) PDBG (pixma_dbg (1, "WARNING:abort_session() failed %s\n", pixma_strerror (error))); /* fall through */ case state_finished: query_status (s); query_status (s); if (mf->generation == 1) { /* activate only seen for generation 1 scanners */ activate (s, 0); query_status (s); } /* 0x38 = last block and ADF empty * 0x28 = last block and Paper in ADF */ if (mf->last_block==0x38 /* ADF empty */ || (mf->generation == 1 && mf->last_block == 0x28)) /* generation 1 scanner or Paper in ADF */ { PDBG (pixma_dbg (3, "*iclass_finish_scan***** abort session *****\n")); abort_session (s); } else PDBG (pixma_dbg (3, "*iclass_finish_scan***** wait for next page from ADF *****\n")); mf->state = state_idle; /* fall through */ case state_idle: break; } }
static int mp730_get_status (pixma_t * s, pixma_device_status_t * status) { int error; error = query_status (s); if (error < 0) return error; status->hardware = PIXMA_HARDWARE_OK; status->adf = (has_paper (s)) ? PIXMA_ADF_OK : PIXMA_ADF_NO_PAPER; return 0; }
static int mp750_get_status (pixma_t * s, pixma_device_status_t * status) { int error; error = query_status (s); if (error < 0) return error; status->hardware = PIXMA_HARDWARE_OK; status->adf = (has_paper (s)) ? PIXMA_ADF_OK : PIXMA_ADF_NO_PAPER; status->cal = (is_calibrated (s)) ? PIXMA_CALIBRATION_OK : PIXMA_CALIBRATION_OFF; status->lamp = (is_warming_up (s)) ? PIXMA_LAMP_WARMING_UP : PIXMA_LAMP_OK; return 0; }
static int step1 (pixma_t * s) { int error; iclass_t *mf = (iclass_t *) s->subdriver; error = query_status (s); if (error < 0) return error; if (s->param->source == PIXMA_SOURCE_ADF && !has_paper (s)) return PIXMA_ENO_PAPER; /* activate only seen for generation 1 scanners */ if (mf->generation == 1) { if (error >= 0) error = activate (s, 0); if (error >= 0) error = activate (s, 4); } return error; }
static int handle_interrupt (pixma_t * s, int timeout) { uint8_t buf[16]; int len; len = pixma_wait_interrupt (s->io, buf, sizeof (buf), timeout); if (len == PIXMA_ETIMEDOUT) return 0; if (len < 0) return len; if (len != 16) { PDBG (pixma_dbg (1, "WARNING:unexpected interrupt packet length %d\n", len)); return PIXMA_EPROTO; } if (buf[12] & 0x40) query_status (s); if (buf[15] & 1) s->events = PIXMA_EV_BUTTON1; return 1; }
struct compile_error expr_parse(struct input ci, struct expr_environ *env, struct parse_options opts, struct objcode **ocode) { struct compile_error ret; struct chain locals = new_chain(); struct proto_obj outp; char *end_ptr; int error = -E_OK, prev_stat=NADA, input_counter = 0; ret = init_ce(); *ocode = NULL; end_ptr = ""; /*force an input read ("" != NULL) */ //error = load_expr(&outp, expr); error = po_init(&outp, opts.n_args, opts.n_rets); while (error == -E_OK && end_ptr != NULL) { char *startptr = end_ptr; data_t tmp_data; int tmp_int; char *ident = NULL; if (eatspace(startptr, &end_ptr)) { /* do nothing */ } else if (*startptr == TERM) { startptr = end_ptr = get_input(ci); } else if (prev_stat == NADA && atodata_load(startptr, &end_ptr, &tmp_data)){ error = inject_data(&outp, tmp_data); prev_stat = NADA; } else if (prev_stat == ARG || prev_stat == NCLEAR) { if (atoint_load(startptr, &end_ptr, &tmp_int)) { if (prev_stat == ARG) error = inject_arg(&outp, tmp_int); else error = inject_nclear(&outp, tmp_int); } else { error = -EXPR_EXPECTING_INT; } prev_stat = NADA; } else if (loadtok(&ident, startptr, &end_ptr)) { int l_index; struct expr_var *tmp_var; if (prev_stat == NADA) { int kwn = strtoKW(ident); switch (kwn) { case KW_VARSET: prev_stat = VARSET; break; case KW_ARG: prev_stat = ARG; break; case KW_FULLCLEAR: error = inject_clear(&outp); prev_stat = NADA; break; case KW_NCLEAR: prev_stat = NCLEAR; break; default: /* not a kw */ { struct expr_func *tmp_fn; struct expr_const *tmp_const; int l_index; if ((l_index = strtoLocal(&locals, ident )) != _NO_SUCH_LOCAL) { error = inject_localvar_get(&outp, l_index); } else if ((tmp_var = strtoVar(&env->vars, ident)) != NULL) { error = inject_globalvar_get(&outp, tmp_var); } else if ((tmp_fn = strtoFun(env, ident)) != NULL) { error = inject_fn(&outp, tmp_fn); } else if ((tmp_const = strtoConst(env, ident)) != NULL) { error = inject_const(&outp, tmp_const); } else { error = -EXPR_NOSYM; } } } } else { if (strtoKW(ident) != NOT_A_KW) { if (prev_stat == VARSET) error = -EXPR_EXPECTING_VAR; else error = -EXPR_EXPECTING_VALUE; } else if (prev_stat == VARSET) { if ((l_index = strtoLocal(&locals, ident )) != _NO_SUCH_LOCAL) { error = inject_localvar_set(&outp, l_index); } else if ((tmp_var = strtoVar(&env->vars, ident)) != NULL) { error = inject_globalvar_set(&outp, tmp_var); } else { l_index =inject_localvar_setdeclare( &outp); if (l_index < 0) { error = l_index; } else { error = ins_local(&locals, ident, l_index); } } } else { error = -EXPR_NOSYM; } prev_stat = NADA; } } else { error = -EXPR_NOSYM; } input_counter += end_ptr - startptr; if (error != -E_OK) { ret.pos = input_counter; ret.lineno = get_lineno(ci); ret.type = error; if (ident != NULL) { ret.fname = ident; ident = NULL; /* prevent free() */ } else { ret.fname = strndup(startptr, end_ptr - startptr); } } free(ident); } { char *bad_string; switch (ret.type) { case -EXPR_ARG_OORANGE: ret.n = query_bad_argument(&outp); break; case -EXPR_FEWARGS: ret.n = query_bf_in(&outp); ret.m = query_bf_real(&outp); break; default: /* <-- includes EXPECTING_STH */ break; case -E_OK: { int nr = query_excess_rets(&outp); if (!opts.auto_clear && nr > 0) ret.type = -EXPR_MANYVALUES; if (ret.type != -E_OK) ret.n = query_n_rets(&outp); else if ((*ocode = po_compile(&outp))==NULL) ret.type = query_status(&outp); } break; } if (ret.fname == NULL && (bad_string = query_bad_fname(&outp)) != NULL) { ret.fname = strdup(bad_string); } } destroy_locals(&locals); if (*ocode == NULL) { po_abort(&outp); } return ret; }
static int step1 (pixma_t * s) { int error, tmo; error = query_status (s); if (error < 0) return error; if ((s->param->source == PIXMA_SOURCE_ADF || s->param->source == PIXMA_SOURCE_ADFDUP) && !has_paper (s)) return PIXMA_ENO_PAPER; if (has_ccd_sensor (s)) { switch (s->cfg->pid) { case MF5730_PID: case MF5750_PID: case MF5770_PID: /* MF57x0: Wait 10 sec before starting for 1st page only */ if (s->param->adf_pageid == 0) { tmo = 10; /* like Windows driver, 10 sec CCD calibration ? */ while (--tmo >= 0) { error = handle_interrupt (s, 1000); \ if (s->cancel) \ return PIXMA_ECANCELED; \ if (error != PIXMA_ECANCELED && error < 0) \ return error; PDBG (pixma_dbg (2, "CCD Calibration ends in %d sec.\n", tmo)); } } break; default: break; } activate (s, 0); error = calibrate (s); switch (s->cfg->pid) { case MF5730_PID: case MF5750_PID: case MF5770_PID: /* MF57x0: calibration returns PIXMA_STATUS_FAILED */ if (error == PIXMA_ECANCELED) error = read_error_info (s, NULL, 0); break; default: break; } } if (error >= 0) error = activate (s, 0); if (error >= 0) error = activate (s, 4); return error; }
static int handle_interrupt (pixma_t * s, int timeout) { uint8_t buf[16]; int len; len = pixma_wait_interrupt (s->io, buf, sizeof (buf), timeout); if (len == PIXMA_ETIMEDOUT) return 0; if (len < 0) return len; switch (s->cfg->pid) { case MP360_PID: case MP370_PID: case MP375R_PID: case MP390_PID: case MF5730_PID: case MF5750_PID: case MF5770_PID: case MF3110_PID: case IR1020_PID: if (len != 16) { PDBG (pixma_dbg (1, "WARNING:unexpected interrupt packet length %d\n", len)); return PIXMA_EPROTO; } if (buf[12] & 0x40) query_status (s); if (buf[10] & 0x40) send_time (s); /* FIXME: following is unverified! */ if (buf[15] & 1) s->events = PIXMA_EV_BUTTON2; /* b/w scan */ if (buf[15] & 2) s->events = PIXMA_EV_BUTTON1; /* color scan */ break; case MP700_PID: case MP730_PID: case MP710_PID: case MP740_PID: if (len != 8) { PDBG (pixma_dbg (1, "WARNING:unexpected interrupt packet length %d\n", len)); return PIXMA_EPROTO; } if (buf[7] & 0x10) s->events = PIXMA_EV_BUTTON1; if (buf[5] & 8) send_time (s); break; default: PDBG (pixma_dbg (1, "WARNING:unknown interrupt, please report!\n")); PDBG (pixma_hexdump (1, buf, len)); } return 1; }
static int mp750_fill_buffer (pixma_t * s, pixma_imagebuf_t * ib) { mp750_t *mp = (mp750_t *) s->subdriver; int error; uint8_t info; unsigned block_size, bytes_received, n; int shift[3], base_shift; int c; c = ((is_ccd_grayscale (s)) ? 3 : s->param->channels) * s->param->depth / 8; /* single-byte or double-byte data */ if (mp->state == state_warmup) { int tmo = 60; query_status (s); check_status (s); /*SIM*/ while (!is_calibrated (s) && --tmo >= 0) { if (s->cancel) return PIXMA_ECANCELED; if (handle_interrupt (s, 1000) > 0) { block_size = 0; error = request_image_block (s, &block_size, &info); /*SIM*/ if (error < 0) return error; } } if (tmo < 0) { PDBG (pixma_dbg (1, "WARNING: Timed out waiting for calibration\n")); return PIXMA_ETIMEDOUT; } pixma_sleep (100000); query_status (s); if (is_warming_up (s) || !is_calibrated (s)) { PDBG (pixma_dbg (1, "WARNING: Wrong status: wup=%d cal=%d\n", is_warming_up (s), is_calibrated (s))); return PIXMA_EPROTO; } block_size = 0; request_image_block (s, &block_size, &info); /*SIM*/ mp->state = state_scanning; mp->last_block = 0; } /* TODO: Move to other place, values are constant. */ base_shift = calc_component_shifting (s) * mp->line_size; if (s->param->source == PIXMA_SOURCE_ADF) { shift[0] = 0; shift[1] = -base_shift; shift[2] = -2 * base_shift; } else { shift[0] = -2 * base_shift; shift[1] = -base_shift; shift[2] = 0; } do { if (mp->last_block_size > 0) { block_size = mp->imgbuf_len - mp->last_block_size; memcpy (mp->img, mp->img + mp->last_block_size, block_size); } do { if (s->cancel) return PIXMA_ECANCELED; if (mp->last_block) { /* end of image */ info = mp->last_block; if (info != 0x38) { query_status (s); /*SIM*/ while ((info & 0x28) != 0x28) { pixma_sleep (10000); error = request_image_block2 (s, &info); if (s->cancel) return PIXMA_ECANCELED; /* FIXME: Is it safe to cancel here? */ if (error < 0) return error; } } mp->needs_abort = (info != 0x38); mp->last_block = info; mp->state = state_finished; return 0; } check_status (s); /*SIM*/ while (handle_interrupt (s, 1) > 0); /*SIM*/ block_size = IMAGE_BLOCK_SIZE; error = request_image_block (s, &block_size, &info); if (error < 0) { if (error == PIXMA_ECANCELED) read_error_info (s, NULL, 0); return error; } mp->last_block = info; if ((info & ~0x38) != 0) { PDBG (pixma_dbg (1, "WARNING: Unknown info byte %x\n", info)); } if (block_size == 0) { /* no image data at this moment. */ pixma_sleep (10000); } } while (block_size == 0); error = read_image_block (s, mp->rawimg + mp->rawimg_left); if (error < 0) { mp->state = state_transfering; return error; } bytes_received = error; PASSERT (bytes_received == block_size); /* TODO: simplify! */ mp->rawimg_left += bytes_received; n = mp->rawimg_left / 3; /* n = number of pixels in the buffer? */ /* Color to Grayscale converion for CCD sensor */ if (is_ccd_grayscale (s)) { shift_rgb (mp->rawimg, n, shift[0], shift[1], shift[2], mp->stripe_shift, mp->line_size, mp->imgcol + mp->imgbuf_ofs); /* dst: img, src: imgcol */ rgb_to_gray (mp->img, mp->imgcol, n, c); /* cropping occurs later? */ PDBG (pixma_dbg (4, "*fill_buffer: did grayscale conversion \n")); } /* Color image processing */ else { shift_rgb (mp->rawimg, n, shift[0], shift[1], shift[2], mp->stripe_shift, mp->line_size, mp->img + mp->imgbuf_ofs); PDBG (pixma_dbg (4, "*fill_buffer: no grayscale conversion---keep color \n")); } /* entering remaining unprocessed bytes after last complete pixel into mp->rawimg buffer -- no influence on mp->img */ n *= 3; mp->shifted_bytes += n; mp->rawimg_left -= n; /* rawimg_left = 0, 1 or 2 bytes left in the buffer. */ mp->last_block_size = n; memcpy (mp->rawimg, mp->rawimg + n, mp->rawimg_left); } while (mp->shifted_bytes <= 0); if ((unsigned) mp->shifted_bytes < mp->last_block_size) { if (is_ccd_grayscale (s)) ib->rptr = mp->img + mp->last_block_size/3 - mp->shifted_bytes/3; /* testing---works OK */ else ib->rptr = mp->img + mp->last_block_size - mp->shifted_bytes; } else ib->rptr = mp->img; if (is_ccd_grayscale (s)) ib->rend = mp->img + mp->last_block_size/3; /* testing---works OK */ else ib->rend = mp->img + mp->last_block_size; return ib->rend - ib->rptr; }
static void waprpl_process_incoming_events(PurpleConnection * gc) { whatsapp_connection *wconn = purple_connection_get_protocol_data(gc); PurpleAccount *acc = purple_connection_get_account(gc); switch (waAPI_loginstatus(wconn->waAPI)) { case 0: purple_connection_update_progress(gc, "Connecting", 0, 4); break; case 1: purple_connection_update_progress(gc, "Sending authorization", 1, 4); break; case 2: purple_connection_update_progress(gc, "Awaiting response", 2, 4); break; case 3: purple_connection_update_progress(gc, "Connection established", 3, 4); purple_connection_set_state(gc, PURPLE_CONNECTED); if (!wconn->connected) waprpl_insert_contacts(gc); wconn->connected = 1; PurpleAccount *account = purple_connection_get_account(gc); PurpleStatus *status = purple_account_get_active_status(account); waprpl_set_status(account, status); break; default: break; }; /* Groups update */ if (waAPI_getgroupsupdated(wconn->waAPI)) { /* Delete/update the chats that are in our list */ PurpleBlistNode *node; for (node = purple_blist_get_root(); node; node = purple_blist_node_next(node, FALSE)) { if (!PURPLE_BLIST_NODE_IS_CHAT(node)) continue; PurpleChat *ch = PURPLE_CHAT(node); if (purple_chat_get_account(ch) != acc) continue; GHashTable *hasht = purple_chat_get_components(ch); char *grid = g_hash_table_lookup(hasht, "id"); char *glist = waAPI_getgroups(wconn->waAPI); gchar **gplist = g_strsplit(glist, ",", 0); if (str_array_find(gplist, grid) >= 0) { /* The group is in the system, update the fields */ char *sub, *own; waAPI_getgroupinfo(wconn->waAPI, grid, &sub, &own, 0); g_hash_table_replace(hasht, g_strdup("subject"), g_strdup(sub)); g_hash_table_replace(hasht, g_strdup("owner"), g_strdup(own)); purple_blist_alias_chat(ch, g_strdup(sub)); } else { /* The group was deleted */ PurpleChat *del = (PurpleChat *) node; node = purple_blist_node_next(node, FALSE); purple_blist_remove_chat(del); } g_strfreev(gplist); } /* Add new groups */ char *glist = waAPI_getgroups(wconn->waAPI); gchar **gplist = g_strsplit(glist, ",", 0); gchar **p; for (p = gplist; *p; p++) { gchar *gpid = *p; PurpleChat *ch = blist_find_chat_by_id(gc, gpid); if (!ch) { char *sub, *own; waAPI_getgroupinfo(wconn->waAPI, gpid, &sub, &own, 0); purple_debug_info("waprpl", "New group found %s %s\n", gpid, sub); GHashTable *htable = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); g_hash_table_insert(htable, g_strdup("subject"), g_strdup(sub)); g_hash_table_insert(htable, g_strdup("id"), g_strdup(gpid)); g_hash_table_insert(htable, g_strdup("owner"), g_strdup(own)); ch = purple_chat_new(acc, sub, htable); purple_blist_add_chat(ch, NULL, NULL); } /* Now update the open conversation that may exist */ char *id = g_hash_table_lookup(purple_chat_get_components(ch), "id"); int prplid = chatid_to_convo(id); PurpleConversation *conv = purple_find_chat(gc, prplid); char *subject, *owner, *part; if (conv && waAPI_getgroupinfo(wconn->waAPI, id, &subject, &owner, &part)) conv_add_participants(conv, part, owner); } g_strfreev(gplist); } /* Incoming messages. */ for (;;) { int r = waAPI_querynext(wconn->waAPI); if (r < 0) break; switch (r) { case 0: query_chat_message(gc); break; case 1: query_chat_image(gc); break; case 2: query_chat_location(gc); break; case 3: query_chat_sound(gc); break; case 4: query_chat_video(gc); break; default: /* Unsupported message type. */ break; }; } /* Status changes, typing notices and profile pictures. */ query_status(gc); query_typing(gc); query_icon(gc); }
static void waprpl_process_incoming_events(PurpleConnection * gc) { whatsapp_connection *wconn = purple_connection_get_protocol_data(gc); PurpleAccount *acc = purple_connection_get_account(gc); int err; do { char * reason; err = waAPI_geterror(wconn->waAPI, &reason); if (err != 0) { PurpleConnectionError errcode = PURPLE_CONNECTION_ERROR_OTHER_ERROR; if (err == 1) errcode = PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED; purple_connection_error_reason(gc, errcode, reason); g_free(reason); } } while (err != 0); switch (waAPI_loginstatus(wconn->waAPI)) { case 0: purple_connection_update_progress(gc, "Connecting", 0, 4); break; case 1: purple_connection_update_progress(gc, "Sending authorization", 1, 4); break; case 2: purple_connection_update_progress(gc, "Awaiting response", 2, 4); break; case 3: if (!wconn->connected) { purple_connection_update_progress(gc, "Connection established", 3, 4); purple_connection_set_state(gc, PURPLE_CONNECTED); PurpleAccount *account = purple_connection_get_account(gc); PurpleStatus *status = purple_account_get_active_status(account); waprpl_insert_contacts(gc); waprpl_set_status(account, status); wconn->connected = 1; } break; default: break; }; /* Groups update */ if (waAPI_getgroupsupdated(wconn->waAPI)) { purple_debug_info(WHATSAPP_ID, "Receiving update information from my groups\n"); /* Delete/update the chats that are in our list */ PurpleBlistNode *node; for (node = purple_blist_get_root(); node; node = purple_blist_node_next(node, FALSE)) { if (!PURPLE_BLIST_NODE_IS_CHAT(node)) continue; PurpleChat *ch = PURPLE_CHAT(node); if (purple_chat_get_account(ch) != acc) continue; GHashTable *hasht = purple_chat_get_components(ch); char *grid = g_hash_table_lookup(hasht, "id"); char *glist = waAPI_getgroups(wconn->waAPI); gchar **gplist = g_strsplit(glist, ",", 0); if (str_array_find(gplist, grid) >= 0) { /* The group is in the system, update the fields */ char *sub, *own; waAPI_getgroupinfo(wconn->waAPI, grid, &sub, &own, 0); g_hash_table_replace(hasht, g_strdup("subject"), sub); g_hash_table_replace(hasht, g_strdup("owner"), own); purple_blist_alias_chat(ch, sub); } else { /* The group was deleted */ PurpleChat *del = (PurpleChat *) node; node = purple_blist_node_next(node, FALSE); purple_blist_remove_chat(del); } g_strfreev(gplist); g_free(glist); } /* Add new groups */ char *glist = waAPI_getgroups(wconn->waAPI); gchar **gplist = g_strsplit(glist, ",", 0); gchar **p; for (p = gplist; *p; p++) { gchar *gpid = *p; PurpleChat *ch = blist_find_chat_by_id(gc, gpid); if (!ch) ch = create_chat_group(gpid, wconn, acc); /* Now update the open conversation that may exist */ char *id = g_hash_table_lookup(purple_chat_get_components(ch), "id"); int prplid = chatid_to_convo(id); PurpleConversation *conv = purple_find_chat(gc, prplid); char *subject, *owner, *part; if (conv && waAPI_getgroupinfo(wconn->waAPI, id, &subject, &owner, &part)) { conv_add_participants(conv, part, owner); } } g_strfreev(gplist); g_free(glist); } t_message m; while (waAPI_querymsg(wconn->waAPI, &m)) { switch (m.type) { case 0: purple_debug_info(WHATSAPP_ID, "Got chat message from %s: %s\n", m.who, m.message); conv_add_message(gc, m.who, m.message, m.author, m.t); break; case 1: { purple_debug_info(WHATSAPP_ID, "Got image from %s: %s\n", m.who, m.message); int imgid = purple_imgstore_add_with_id(g_memdup(m.image, m.imagelen), m.imagelen, NULL); char *msg = g_strdup_printf("<a href=\"%s\"><img id=\"%u\"></a><br/><a href=\"%s\">%s</a>", m.url, imgid, m.url, m.url); conv_add_message(gc, m.who, msg, m.author, m.t); g_free(msg); } break; case 2: { purple_debug_info(WHATSAPP_ID, "Got geomessage from: %s Coordinates (%f %f)\n", m.who, (float)m.lat, (float)m.lng); char * lat = dbl2str(m.lat); char * lng = dbl2str(m.lng); char *msg = g_strdup_printf("<a href=\"http://openstreetmap.org/?lat=%s&lon=%s&zoom=20\">" "http://openstreetmap.org/?lat=%s&lon=%s&zoom=20</a>", lat, lng, lat, lng); conv_add_message(gc, m.who, msg, m.author, m.t); g_free(msg); g_free(lng); g_free(lat); } break; case 3: { purple_debug_info(WHATSAPP_ID, "Got chat sound from %s: %s\n", m.who, m.url); char *msg = g_strdup_printf("<a href=\"%s\">%s</a>", m.url, m.url); conv_add_message(gc, m.who, msg, m.author, m.t); g_free(msg); } break; case 4: { purple_debug_info(WHATSAPP_ID, "Got chat video from %s: %s\n", m.who, m.url); char *msg = g_strdup_printf("<a href=\"%s\">%s</a>", m.url, m.url); conv_add_message(gc, m.who, msg, m.author, m.t); g_free(msg); } break; case 5: { purple_debug_info(WHATSAPP_ID, "Got phone call from %s\n", m.who); conv_add_message(gc, m.who, "[Trying to voice-call you]", m.author, m.t); } break; default: purple_debug_info(WHATSAPP_ID, "Got an unrecognized message!\n"); break; }; g_free(m.who); g_free(m.author); g_free(m.message); } while (1) { int typer; char msgid[128]; if (!waAPI_queryreceivedmsg(wconn->waAPI, msgid, &typer)) break; purple_debug_info(WHATSAPP_ID, "Received message %s type: %d\n", msgid, typer); purple_signal_emit(purple_connection_get_prpl(gc), "whatsapp-message-received", gc, msgid, typer); } /* Status changes, typing notices and profile pictures. */ query_status(gc); query_typing(gc); query_icon(gc); }
int main(int argc, char **argv) { int rc = 0; int ch = 0; mysql_connection_t conn; char *node = NULL; char *mask_str = NULL; int port = -1; #if HAVE_LIBGENDERS static char const str_opts[] = "hCc:sr:Rp:eE:Sf"; #else static char const str_opts[] = "hCc:sr:Rp:eE:S"; #endif static const struct option long_opts [] = { {"help", 0, 0, 'h'}, {"clear-all", 0, 0, 'C'}, {"clear", 1, 0, 'c'}, {"report", 1, 0, 'r'}, {"report-all", 0, 0, 'R'}, {"report-error", 0, 0, 'e'}, {"report-error-mask", 1, 0, 'E'}, {"port", 1, 0, 'p'}, {"show-queries", 0, 0, 's'}, {"node-name-map", 1, 0, 1}, {"line-mode", 0, 0, 'l'}, #if HAVE_LIBGENDERS {"sum-fabric-errors", 0, 0, 'f'}, #endif { } }; argv0 = argv[0]; while ((ch = getopt_long(argc, argv, str_opts, long_opts, NULL)) != -1) { switch (ch) { case 1: node_name_map_file = strdup(optarg); break; case 'C': printf("clearing all\n"); mode = CLEAR_ALL; break; case 'c': printf("clearing node %s\n", optarg); node = strdup(optarg); mode = CLEAR_NODE; break; case 'r': node = strdup(optarg); mode = REPORT_NODE; break; case 'R': mode = REPORT_ALL; break; case 'e': mode = REPORT_ERROR; break; case 'E': mode = REPORT_ERROR; mask_str = strdup(optarg); break; case 'p': port = atoi(optarg); if (port <= 0) { fprintf(stderr, "Invalid port value specified : \"%d\"\n", port); usage(); exit(1); } if (mode == QUERY_ALL) { mode = REPORT_ALL; } break; case 's': show_queries = 1; break; case 'S': skummee_output = 1; break; #if HAVE_LIBGENDERS case 'f': sum_fabric_errors = 1; break; #endif case 'h': default: usage(); exit(0); } } node_name_map = open_node_name_map(node_name_map_file); /* work */ construct_mysql_connection(&conn); sql_setup_db_conn(&conn); switch (mode) { case CLEAR_NODE: rc = clear_node(&conn, node); break; case REPORT_NODE: rc = report(&conn, node, port); break; case REPORT_ALL: rc = report(&conn, NULL, port); break; case REPORT_ERROR: rc = report_error(&conn, mask_str); break; case CLEAR_ALL: rc = clear_all(&conn); break; default: case QUERY_ALL: rc = query_status(&conn); break; } mysql_close(&(conn.mysql)); close_node_name_map(node_name_map); return (rc); }