/* PROTO */ void imcomm_request_awayprofile(void *handle, char *sn) { pkt_t *packet; struct MultiPacket *mpkt; mpkt = MultiPktInit(); packet = pkt_init(3 + (uint8_t) strlen(sn)); pkt_add16(packet, 0x0003); pkt_add8(packet, (uint8_t) strlen(sn)); pkt_addraw(packet, (uint8_t *) sn, strlen(sn)); snac_addToMulti(handle, mpkt, 0x02, 0x05, packet->data, packet->len, 0); pkt_free(packet); packet = pkt_init(3 + (uint8_t) strlen(sn)); pkt_add16(packet, 0x0001); pkt_add8(packet, (uint8_t) strlen(sn)); pkt_addraw(packet, (uint8_t *) sn, strlen(sn)); snac_addToMulti(handle, mpkt, 0x02, 0x05, packet->data, packet->len, 0); pkt_free(packet); flap_sendMulti(handle, mpkt); MultiPktFree(mpkt); }
/* PROTO */ IMCOMM_RET snac_send_cli_update(void *handle) { IMCOMM_RET ret; pkt_t *pkt; /* * This makes the server send us extended status information */ #if 0 pkt = pkt_init(12); pkt_add16(pkt, 0x001d); pkt_add16(pkt, 0x0008); pkt_add32(pkt, 0x00020404); pkt_add32(pkt, 0x00000000); #endif pkt = pkt_init(8); pkt_add16(pkt, 0x0006); pkt_add16(pkt, 0x0004); if (((IMCOMM *) handle)->isinvisible) pkt_add32(pkt, 0x00000100); else pkt_add32(pkt, 0x00000000); ret = snac_sendpkt(handle, 0x01, 0x1e, pkt, 0); pkt_free(pkt); return ret; }
/**************************************************************************** * ow_write_big_block_depot(struct owctx *ow) * * Write big block depot. */ void ow_write_big_block_depot(struct owctx *ow) { int num_blocks = ow->big_blocks; int num_lists = ow->list_blocks; int total_blocks = num_lists * 128; int used_blocks = num_blocks + num_lists + 2; struct pkt *pkt; int i; pkt = pkt_init(0, VARIABLE_PACKET); for (i = 1; i <= num_blocks - 1; i++) { pkt_add32_le(pkt, i); } /* End of chain */ pkt_add32_le(pkt, -2); pkt_add32_le(pkt, -2); for (i = 1; i <= num_lists; i++) { pkt_add32_le(pkt, -3); } for (i = used_blocks; i <= total_blocks; i++) { pkt_add32_le(pkt, -1); } ow->io_handler.write(ow->io_handle,pkt->data, pkt->len); pkt_free(pkt); }
/** * pkt_recv - receive packet * @fd: file descriptor to read * * Reads the next packet from @fd. A new lo_packet is created and returned. * On error, %NULL is returned, in which case the stream (@fd) will be in * an undefined state. */ struct lo_packet *pkt_recv(int fd) { struct ccgfs_pkt_header *hdr; struct lo_packet *pkt; ssize_t ret; int err; pkt = pkt_init(0, 0); hdr = pkt->data; ret = reliable_read(fd, hdr, sizeof(*hdr)); if (ret != sizeof(*hdr)) { err = errno; pkt_destroy(pkt); errno = err; return NULL; } hdr->opcode = le32_to_cpu(hdr->opcode); hdr->length = le32_to_cpu(hdr->length); hdr = pkt_resize(pkt, hdr->length); pkt->length = hdr->length; ret = reliable_read(fd, pkt->data + sizeof(*hdr), pkt->length - sizeof(*hdr)); if (ret != pkt->length - sizeof(*hdr)) { err = errno; pkt_destroy(pkt); errno = err; return NULL; } return pkt; }
usb_dev_handle *usb_open(struct usb_device *dev) { // Get remote fd Packet* pkt = pkt_claim(); int fd = session_get(); // Send packet pkt_init(pkt, UsbOpen); pkt_adduint(pkt, dev->bus->location); pkt_adduint(pkt, dev->devnum); pkt_send(pkt, fd); // Get response int res = -1, devfd = -1; if(pkt_recv(fd, pkt) > 0 && pkt_op(pkt) == UsbOpen) { Iterator it; pkt_begin(pkt, &it); res = iter_getint(&it); devfd = iter_getint(&it); } // Evaluate usb_dev_handle* udev = NULL; if(res >= 0) { udev = malloc(sizeof(usb_dev_handle)); udev->fd = devfd; udev->device = dev; udev->bus = dev->bus; udev->config = udev->interface = udev->altsetting = -1; } pkt_release(); debug_msg("returned %d (fd %d)", res, devfd); return udev; }
/* PROTO */ void imcomm_im_send_message(void *handle, const char *whom, const char *msg, int automsg) { pkt_t *packet; packet = pkt_init(28 + strlen(whom) + strlen(msg) + (4 * automsg)); /* * Message cookie? * * Putting something random seems to work. */ pkt_add32(packet, 0x01020304); pkt_add32(packet, 0x05060708); pkt_add16(packet, 0x0001); pkt_add8(packet, (uint8_t) strlen(whom)); pkt_addraw(packet, (uint8_t *) whom, strlen(whom)); pkt_add16(packet, 0x0002); pkt_add16(packet, (uint16_t) (uint16_t) (strlen(msg) + 13)); pkt_add32(packet, 0x05010001); pkt_add8(packet, 0x01); pkt_add16(packet, 0x0101); pkt_add16(packet, (uint16_t) (uint16_t) (strlen(msg) + 4)); pkt_add32(packet, 0x00000000); pkt_addraw(packet, (uint8_t *) msg, strlen(msg)); if (automsg) { pkt_add16(packet, 0x0004); pkt_add16(packet, 0x0000); } snac_sendpkt(handle, 0x04, 0x06, packet, (automsg ? 0 : 1)); pkt_free(packet); }
/* Writes Excel BIFF BOUNDSHEET record */ void wbook_store_boundsheet(struct wbookctx *wbook, char *sname, int offset) { uint16_t name = 0x0085; /* Record identifier */ uint16_t length; uint16_t grbit = 0x0000; int cch; struct pkt *pkt; length = 0x07 + strlen(sname); /* Number of bytes to follow */ cch = strlen(sname); pkt = pkt_init(0, VARIABLE_PACKET); /* Write header */ pkt_add16_le(pkt, name); pkt_add16_le(pkt, length); /* Write data */ pkt_add32_le(pkt, offset); /* Location of worksheet BOF */ pkt_add16_le(pkt, grbit); /* Sheet identifier */ pkt_add8(pkt, cch); /* Length of sheet name */ pkt_addraw(pkt, (unsigned char *)sname, cch); bw_append(wbook->biff, pkt->data, pkt->len); pkt_free(pkt); }
/* PROTO */ IMCOMM_RET snac_ack_limits(void *handle, unsigned char *data, size_t len) { pkt_t *pkt; uint16_t x, y, num_classes, *ids; num_classes = two_to_16(data); ids = malloc(num_classes * 2); /* it's a 16 bit type, so we need * twice the bytes. Thanks to djgpp * for catching this bug! UNIX/win32 * let it go. */ for (x = 2, y = 0; y < num_classes; y++) { ids[y] = two_to_16(data + x); x += 35; } pkt = pkt_init(num_classes * 2); for (y = 0; y < num_classes; y++) pkt_add16(pkt, ids[y]); if (snac_sendpkt(handle, 0x01, 0x08, pkt, 0) != IMCOMM_RET_OK) { pkt_free(pkt); free(ids); return IMCOMM_RET_ERROR; } pkt_free(pkt); free(ids); return snac_multireq(handle); }
int usb_get_driver_np(usb_dev_handle *dev, int interface, char *name, unsigned int namelen) { // Get remote fd Packet* pkt = pkt_claim(); int fd = session_get(); // Send packet pkt_init(pkt, UsbGetKernelDriver); pkt_addint(pkt, dev->fd); pkt_addint(pkt, interface); pkt_adduint(pkt, namelen); pkt_send(pkt, fd); // Get response int res = -1; if(pkt_recv(fd, pkt) > 0 && pkt_op(pkt) == UsbGetKernelDriver) { Iterator it; pkt_begin(pkt, &it); res = iter_getint(&it); // Error if(res) { error_msg("%s: could not get bound driver", __func__); } // Save string strncpy(name, iter_getstr(&it), namelen - 1); name[namelen - 1] = '\0'; } pkt_release(); debug_msg("returned %d (%s)", res, name); return res; }
/**************************************************************************** * bw_store_bof(struct bwctx *bw, uint16_t type) * * type = 0x0005, Workbook * type = 0x0010, Worksheet * * Writes Excel BOF (Beginning of File) record to indicate the beginning of * a stream or substream in the BIFF file */ void bw_store_bof(struct bwctx *bw, uint16_t type) { uint16_t name = 0x0809; /* Record identifier */ uint16_t length = 0x0008; /* Number of bytes to follow */ /* According to the SDK "build" and "year" should be set to zero. * However, this throws a warning in Excel 5. So, use these * magic umbers */ uint16_t build = 0x096C; uint16_t year = 0x07C9; struct pkt *pkt; pkt = pkt_init(12, FIXED_PACKET); /* Construct header */ pkt_add16_le(pkt, name); pkt_add16_le(pkt, length); /* Construct data */ pkt_add16_le(pkt, g_BIFF_version); pkt_add16_le(pkt, type); pkt_add16_le(pkt, build); pkt_add16_le(pkt, year); bw_prepend(bw, pkt->data, pkt->len); pkt_free(pkt); }
/* libusb(5): * Interrupt transfers. */ int usb_interrupt_write(usb_dev_handle *dev, int ep, usb_buf_t bytes, int size, int timeout) { // Get remote fd Packet* pkt = pkt_claim(); int fd = session_get(); // Prepare packet pkt_init(pkt, UsbInterruptWrite); pkt_addint(pkt, dev->fd); pkt_addint(pkt, ep); pkt_addstr(pkt, size, bytes); pkt_addint(pkt, timeout); pkt_send(pkt, fd); // Get response int res = -1; if(pkt_recv(fd, pkt) > 0 && pkt_op(pkt) == UsbInterruptWrite) { Iterator it; pkt_begin(pkt, &it); res = iter_getint(&it); } // Return response pkt_release(); debug_msg("returned %d", res); return res; }
int usb_interrupt_read(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout) { // Get remote fd Packet* pkt = pkt_claim(); int fd = session_get(); // Prepare packet pkt_init(pkt, UsbInterruptRead); pkt_addint(pkt, dev->fd); pkt_addint(pkt, ep); pkt_addint(pkt, size); pkt_addint(pkt, timeout); pkt_send(pkt, fd); // Get response int res = -1; if(pkt_recv(fd, pkt) > 0 && pkt_op(pkt) == UsbInterruptRead) { Iterator it; pkt_begin(pkt, &it); res = iter_getint(&it); if(res > 0) { int minlen = (res > size) ? size : res; memcpy(bytes, it.val, minlen); } } // Return response pkt_release(); debug_msg("returned %d", res); return res; }
int usb_reset(usb_dev_handle *dev) { // Get remote fd Packet* pkt = pkt_claim(); int fd = session_get(); // Prepare packet pkt_init(pkt, UsbReset); pkt_addint(pkt, dev->fd); pkt_send(pkt, fd); // Get response int res = -1; if(pkt_recv(fd, pkt) > 0 && pkt_op(pkt) == UsbReset) { Iterator it; pkt_begin(pkt, &it); // Read result res = iter_getint(&it); } // Return response pkt_release(); debug_msg("returned %d", res); return res; }
int usb_set_altinterface(usb_dev_handle *dev, int alternate) { // Get remote fd Packet* pkt = pkt_claim(); int fd = session_get(); // Prepare packet pkt_init(pkt, UsbSetAltInterface); pkt_addint(pkt, dev->fd); pkt_addint(pkt, alternate); pkt_send(pkt, fd); // Get response int res = -1; if(pkt_recv(fd, pkt) > 0 && pkt_op(pkt) == UsbSetAltInterface) { Iterator it; pkt_begin(pkt, &it); // Read result res = iter_getint(&it); // Read callback configuration alternate = iter_getint(&it); } // Save configuration dev->altsetting = alternate; // Return response pkt_release(); debug_msg("returned %d", res); return res; }
int usb_close(usb_dev_handle *dev) { // Get remote fd Packet* pkt = pkt_claim(); int fd = session_get(); // Send packet pkt_init(pkt, UsbClose); pkt_addint(pkt, dev->fd); pkt_send(pkt, fd); // Free device free(dev); // Get response int res = -1; if(pkt_recv(fd, pkt) > 0 && pkt_op(pkt) == UsbClose) { Iterator it; pkt_begin(pkt, &it); res = iter_getint(&it); } pkt_release(); debug_msg("returned %d", res); return res; }
/* PROTO */ IMCOMM_RET snac_ack_srv_pause(void *handle, uint8_t * data, size_t len) { pkt_t *ackpkt; struct IMComm_Families *tr; int count; for (count = 0, tr = ((IMCOMM *) handle)->families; tr; tr = tr->next) count++; ackpkt = pkt_init(count * 2); /* each family is 16 bits */ for (tr = ((IMCOMM *) handle)->families; tr; tr = tr->next) { pkt_add16(ackpkt, tr->family); printf("adding family %d (total %d).\n", tr->family, count); } ((IMCOMM *) handle)->srv_pause = 1; /* return snac_send(handle, 0x01, 0x0c, data, len, 0); */ snac_sendpkt(handle, 0x01, 0x0c, ackpkt, 0); pkt_free(ackpkt); return IMCOMM_RET_OK; }
/* PROTO */ void snac_request_new_service(void *handle, uint16_t service) { pkt_t *pkt; pkt = pkt_init(2); pkt_add16(pkt, service); snac_sendpkt(handle, 0x01, 0x04, pkt, 0); pkt_free(pkt); }
/* PROTO */ void imcomm_im_add_buddy(void *handle, char *sn) { IMCOMM_BUDDYLIST *temp, *trav; struct MultiPacket *mpkt; pkt_t *packet; char *sname; uint16_t nextid; sname = imcomm_simplify_sn(sn); for (trav = ((IMCOMM *) handle)->buddylist; trav != NULL; trav = trav->next) { if (strcmp(sname, trav->sn) == 0) { free(sname); return; } } nextid = imcomm_get_next_id(handle); temp = malloc(sizeof(IMCOMM_BUDDYLIST)); temp->sn = sname; temp->formattedsn = strdup(sname); temp->ssi_id = nextid; temp->next = NULL; if (((IMCOMM *) handle)->buddylist == NULL) ((IMCOMM *) handle)->buddylist = temp; else { for (trav = ((IMCOMM *) handle)->buddylist; trav->next != NULL; trav = trav->next); trav->next = temp; } mpkt = MultiPktInit(); snac_addToMulti(handle, mpkt, 0x13, 0x11, NULL, 0, 0); packet = pkt_init(10 + strlen(sname)); pkt_add16(packet, (uint16_t) strlen(sname)); pkt_addraw(packet, (unsigned char *) sname, strlen(sname)); pkt_add16(packet, 0x0001); pkt_add16(packet, nextid); pkt_add16(packet, 0x0000); pkt_add16(packet, 0x0000); snac_addToMulti(handle, mpkt, 0x13, 0x08, packet->data, packet->len, 0); pkt_free(packet); snac_addToMulti(handle, mpkt, 0x13, 0x012, NULL, 0, 0); flap_sendMulti(handle, mpkt); MultiPktFree(mpkt); }
/**************************************************************************** * ow_write_header(struct owctx *ow) * * Write OLE header block. */ void ow_write_header(struct owctx *ow) { int root_start; int num_lists; struct pkt *pkt; int i; if (ow->biff_only) return; ow_calculate_sizes(ow); root_start = ow->root_start; num_lists = ow->list_blocks; pkt = pkt_init(0, VARIABLE_PACKET); pkt_add32(pkt, 0xD0CF11E0); /* OLE document file id part 1 */ pkt_add32(pkt, 0xA1B11AE1); /* OLE document file id part 2 */ pkt_add32_le(pkt, 0x00); /* UID of this file (can be all 0's) 1/4 */ pkt_add32_le(pkt, 0x00); /* UID of this file (can be all 0's) 2/4 */ pkt_add32_le(pkt, 0x00); /* UID of this file (can be all 0's) 3/4 */ pkt_add32_le(pkt, 0x00); /* UID of this file (can be all 0's) 4/4 */ pkt_add16_le(pkt, 0x3E); /* Revision number (almost always 0x003E) */ pkt_add16_le(pkt, 0x03); /* Version number (almost always 0x0003) */ pkt_add16(pkt, 0xFEFF); /* Byte order identifier: * (0xFEFF = Little Endian) * (0xFFFE = Big Endian) */ pkt_add16_le(pkt, 0x09); /* 2^x (9 = 512 bytes) */ pkt_add32_le(pkt, 0x06); /* Unknown 5 */ pkt_add32_le(pkt, 0x00); /* Unknown 5 */ pkt_add32_le(pkt, 0x00); /* Unknown 5 */ pkt_add32_le(pkt, num_lists); /* num_bbd_blocks */ pkt_add32_le(pkt, root_start); /* root_startblock */ pkt_add32_le(pkt, 0x00); /* Unknown 6 */ pkt_add32_le(pkt, 0x1000); /* Unknown 6 */ pkt_add32_le(pkt, -2); /* sbd_startblock */ pkt_add32_le(pkt, 0x00); /* Unknown 7 */ pkt_add32_le(pkt, -2); /* Unknown 7 */ pkt_add32_le(pkt, 0x00); /* Unknown 7 */ for (i = 1; i <= num_lists; i++) { root_start++; pkt_add32_le(pkt, root_start); } for (i = num_lists; i <= 108; i++) { pkt_add32_le(pkt, -1); /* Unused */ } ow->io_handler.write(ow->io_handle,pkt->data, pkt->len); pkt_free(pkt); }
static inline struct lo_packet *mpkt_init(unsigned int type, unsigned int length) { const struct fuse_context *ctx = fuse_get_context(); struct lo_packet *pkt; pkt = pkt_init(type, length + 2 * PV_32); pkt_push_32(pkt, ctx->uid); pkt_push_32(pkt, ctx->gid); return pkt; }
/* PROTO */ ssize_t send_cmdpkt(void *handle, pkt_t *packet) { pkt_t *n; ssize_t ret; n = pkt_init(2+packet->len); pkt_addraw(n, packet->data, packet->len); pkt_addraw(n, (unsigned char *)"\r\n", 2); ret = sendPkt(handle, n); pkt_free(n); return ret; }
/* PROTO */ void imcomm_request_awaymsg(void *handle, char *sn) { pkt_t *packet; packet = pkt_init(3 + (uint8_t) strlen(sn)); pkt_add16(packet, 0x0003); pkt_add8(packet, (uint8_t) strlen(sn)); pkt_addraw(packet, (uint8_t *) sn, strlen(sn)); snac_sendpkt(handle, 0x02, 0x05, packet, 0); pkt_free(packet); }
/** Initialize USB subsystem. */ void usb_init(void) { // Initialize packet & remote fd Packet* pkt = pkt_claim(); int fd = session_get(); // Create buffer pkt_init(pkt, UsbInit); pkt_send(pkt, fd); pkt_release(); // Initialize locally debug_msg("called"); }
/**************************************************************************** * bw_store_eof(struct bwctx *bw) * * Writes Excel EOF (End of File) record to indicate the end of a BIFF stream. */ void bw_store_eof(struct bwctx *bw) { struct pkt *pkt; uint16_t name = 0x000A; /* Record identifier */ uint16_t length = 0x0000; /* Number of bytes to follow */ pkt = pkt_init(4, FIXED_PACKET); /* Construct header */ pkt_add16_le(pkt, name); pkt_add16_le(pkt, length); bw->append(bw, pkt->data, pkt->len); pkt_free(pkt); }
/*! \brief Allocate new packet using memory context. */ static knot_pkt_t *pkt_new_mm(void *wire, uint16_t len, mm_ctx_t *mm) { assert(mm); knot_pkt_t *pkt = mm_alloc(mm, sizeof(knot_pkt_t)); if (pkt == NULL) { return NULL; } if (pkt_init(pkt, wire, len, mm) != KNOT_EOK) { mm_free(mm, pkt); return NULL; } return pkt; }
int main(){ s_pkt_gl *pkt_gl = pkt_init(); if (!pkt_gl ){ printf("[INIT ERROR]\n"); exit(-1); } pkt_proc(pkt_gl); //如果在处理的时候突然崩了的话,pkt_gl没有释放资源,很危险的啊! clean(pkt_gl); return 0; }
/* Write Excel 1904 record to indicate the date system in use. */ static void wbook_store_1904(struct wbookctx *wbook) { struct pkt *pkt; pkt = pkt_init(6, FIXED_PACKET); /* Write header */ pkt_add16_le(pkt, 0x0022); /* Record identifier */ pkt_add16_le(pkt, 0x0002); /* Write data */ pkt_add16_le(pkt, wbook->epoch1904); /* Flag for 1904 date system */ bw_append(wbook->biff, pkt->data, pkt->len); pkt_free(pkt); }
/* Stores the CODEPAGE biff record */ static void wbook_store_codepage(struct wbookctx *wbook) { struct pkt *pkt; pkt = pkt_init(6, FIXED_PACKET); /* Write header */ pkt_add16_le(pkt, 0x0042); /* Record identifier */ pkt_add16_le(pkt, 0x0002); /* Write data */ pkt_add16_le(pkt, wbook->codepage); bw_append(wbook->biff, pkt->data, pkt->len); pkt_free(pkt); }
/**************************************************************************** * ow_write_pps(struct owctx *ow, char *name) * * Write property sheet in property storage */ void ow_write_pps(struct owctx *ow, char *name, int pps_type, int pps_dir, int pps_start, int pps_size) { unsigned char header[64]; int length; struct pkt *pkt; memset(header, 0, sizeof(header)); length = 0; if (name != NULL) { /* Simulate a unicode string */ char *p = name; int i = 0; while (*p != '\0') { header[i] = *p++; i += 2; } length = (strlen(name) * 2) + 2; } pkt = pkt_init(0, VARIABLE_PACKET); pkt_addraw(pkt, header, sizeof(header)); pkt_add16_le(pkt, length); /* pps_sizeofname 0x40 */ pkt_add16_le(pkt, pps_type); /* 0x42 */ pkt_add32_le(pkt, -1); /* pps_prev 0x44 */ pkt_add32_le(pkt, -1); /* pps_next 0x48 */ pkt_add32_le(pkt, pps_dir); /* pps_dir 0x4C */ pkt_add32_le(pkt, 0); /* unknown 0x50 */ pkt_add32_le(pkt, 0); /* unknown 0x54 */ pkt_add32_le(pkt, 0); /* unknown 0x58 */ pkt_add32_le(pkt, 0); /* unknown 0x5C */ pkt_add32_le(pkt, 0); /* unknown 0x60 */ pkt_add32_le(pkt, 0); /* pps_ts1s 0x64 */ pkt_add32_le(pkt, 0); /* pps_ts1d 0x68 */ pkt_add32_le(pkt, 0); /* pps_ts2s 0x6C */ pkt_add32_le(pkt, 0); /* pps_ts2d 0x70 */ pkt_add32_le(pkt, pps_start); /* pps_start 0x74 */ pkt_add32_le(pkt, pps_size); /* pps_size 0x78 */ pkt_add32_le(pkt, 0); /* unknown 0x7C */ ow->io_handler.write(ow->io_handle,pkt->data, pkt->len); pkt_free(pkt); }
/* PROTO */ void snac_addToMulti(void *handle, struct MultiPacket * mpkt, uint16_t family, uint16_t subtype, unsigned char *data, uint16_t len, int updateidle) { pkt_t *snac_packet; snac_packet = pkt_init(len + 10); pkt_add16(snac_packet, family); pkt_add16(snac_packet, subtype); pkt_add16(snac_packet, 0); pkt_add32(snac_packet, ((IMCOMM *) handle)->snacreq); pkt_addraw(snac_packet, (uint8_t *) data, len); ((IMCOMM *) handle)->snacreq++; flap_addToMulti(mpkt, 0x02, snac_packet->data, snac_packet->len, updateidle); pkt_free(snac_packet); }