SANE_Status
sane_start (SANE_Handle h)
{
struct device_s *dev = (struct device_s *) h;
int status;
size_t size;
dev->read_offset = 0;
dev->write_offset_r = 0;
dev->write_offset_g = 1;
dev->write_offset_b = 2;
free (dev->buffer);
dev->buffer = NULL;
send_pkt (PKT_RESET, 0, dev);
send_pkt (PKT_READ_STATUS, 0, dev);
wait_ack (dev, &status);
if (status)
return SANE_STATUS_IO_ERROR;
send_pkt (PKT_READCONF, 0, dev);
if ((size = wait_ack (dev, NULL)))
{
sanei_usb_read_bulk (dev->dn, (unsigned char *) dev->conf_data, &size);
}
send_pkt (PKT_SETCONF, 100, dev);
send_conf (dev);
wait_ack (dev, NULL);
send_pkt (PKT_START_SCAN, 0, dev);
wait_ack (dev, NULL);
if ((size = wait_ack (dev, NULL)))
{
sanei_usb_read_bulk (dev->dn, (unsigned char *) dev->conf_data, &size);
}
if ((size = wait_ack (dev, NULL)))
{
sanei_usb_read_bulk (dev->dn, (unsigned char *) dev->conf_data, &size);
}
if ((size = wait_ack (dev, NULL)))
{
sanei_usb_read_bulk (dev->dn, (unsigned char *) dev->conf_data, &size);
}
dev->status = STATUS_SCANNING;
/* Get the first data */
return get_data (dev);
}
int
network_send_pkt(network_address_t dest_address, int hdr_len,
char* hdr, int data_len, char* data) {
if (synthetic_network) {
if(genrand() < loss_rate)
return (hdr_len+data_len);
if(genrand() < duplication_rate)
send_pkt(dest_address, hdr_len, hdr, data_len, data);
}
return send_pkt(dest_address, hdr_len, hdr, data_len, data);
}
/* called from layer 3, when a packet arrives for layer 4 */
void A_input(struct pkt packet)
{
printf("CCH> A_input> Got packet\n");
// isChecksumValid
if(pkt_checksum_valid(&packet)) {
printf("CCH> A_input> Valid checksum\n");
// isACK
if(strncmp(packet.payload, ACK, strlen(ACK)) == 0) {
if(packet.acknum == last_pkt->seqnum) {
printf("CCH> A_input> Received valid ACK\n");
last_ack = &packet;
stoptimer(A);
} else {
// We received an ACK we don't care about
printf("CCH> A_input> Received invalid ACK (ignoring)\n");
}
// isNACK
} else if (strncmp(packet.payload, NACK, strlen(ACK)) == 0) {
printf("CCH> A_input> Received NACK\n");
send_pkt(A, last_pkt);
} else {
// Message
stoptimer(A);
tolayer5(A, packet.payload);
}
} else {
printf("CCH> A_input> Invalid checksum\n");
send_nack(A, &packet);
stoptimer(A);
starttimer(A, TIMEOUT);
return;
}
}
int do_cmd_1_arg(QSP_ARG_DECL Cmd_Index cmd_index, int data_word)
{
u_short len;
char pkt[20];
USB2000_Cmd_Def *ucdp;
ucdp = &usb2000_cmd_tbl[cmd_index];
make_pkt( pkt, ucdp->ucd_cmd, data_word );
send_pkt(QSP_ARG pkt);
len = strlen(pkt);
if( get_echo(QSP_ARG pkt) < 0 )
return -1;
if ( recv_a_byte(SINGLE_QSP_ARG) != ACK ) {
WARN("ERROR: no ACK received");
return -1;
}
if( get_tail(SINGLE_QSP_ARG) < 0 )
return -1;
return 0;
}
int rom_send_DATA(CalcHandle* handle, uint32_t addr)
{
ticalcs_info(" PC->TI: REQ_BLOCK at @%08x", addr);
TRYF(send_pkt(handle, CMD_REQ_BLOCK, 4, (uint8_t *)&addr));
return 0;
}
static int
test_ping(void)
{
struct pkt *pkt;
struct timeval tv;
printf("ping: "); fflush(stdout);
ping->pkt_icmp_msg->echo.icmp_id = rand_uint16(ctx.rnd);
pkt = pkt_dup(ping);
pkt->pkt_ip->ip_id = rand_uint16(ctx.rnd);
ip_checksum(pkt->pkt_ip, pkt->pkt_end - pkt->pkt_eth_data);
pcap_filter(ctx.pcap, "icmp[0] = 0 and src %s and dst %s",
addr_ntoa(&ctx.dst), addr_ntoa(&ctx.src));
send_pkt(pkt);
for (tv = read_tv; (pkt = recv_pkt(&tv)) != NULL; tv = read_tv) {
if (memcmp(&pkt->pkt_icmp_msg->echo,
&ping->pkt_icmp_msg->echo, 8) == 0)
break;
}
printf("%s\n", pkt ? timeval_ntoa(&tv) : "no reply");
return (0);
}
int
network_send_pkt(network_address_t dest_address, int hdr_len,
char* hdr, int data_len, char* data) {
//printf("network_send_pkt: called\n"); //DEBUG
//printf("network_send_pkt : synthetic network - %d\n", synthetic_network);
if (synthetic_network) {
if(genrand() < loss_rate)
return (hdr_len+data_len);
if(genrand() < duplication_rate)
send_pkt(dest_address, hdr_len, hdr, data_len, data);
}
//printf("call send_pkt\n");
return send_pkt(dest_address, hdr_len, hdr, data_len, data);
}
int rom_send_ERR(CalcHandle* handle)
{
ticalcs_info(" PC->TI: ERROR");
TRYF(send_pkt(handle, CMD_ERROR, 0, NULL));
return 0;
}
int rom_send_RDY(CalcHandle* handle)
{
ticalcs_info(" PC->TI: IS_READY");
TRYF(send_pkt(handle, CMD_IS_READY, 0, NULL));
return 0;
}
int rom_send_SIZE(CalcHandle* handle)
{
ticalcs_info(" PC->TI: REQ_SIZE");
TRYF(send_pkt(handle, CMD_REQ_SIZE, 0, NULL));
return 0;
}
int
network_bcast_pkt(int hdr_len, char* hdr, int data_len, char* data)
{
int i;
int me;
AbortOnCondition(!BCAST_ENABLED,
"Error: network broadcast not enabled.");
if (BCAST_USE_TOPOLOGY_FILE) {
me = topology.me;
for (i=0; i<topology.entries[me].n_links; i++) {
int dest = topology.entries[me].links[i];
if (synthetic_network) {
if(genrand() < loss_rate)
continue;
if(genrand() < duplication_rate)
send_pkt(topology.entries[dest].addr, hdr_len, hdr, data_len, data);
}
if (send_pkt(topology.entries[dest].addr,
hdr_len, hdr, data_len, data) != hdr_len + data_len)
return -1;
}
if (BCAST_LOOPBACK) {
if (send_pkt(topology.entries[me].addr,
hdr_len, hdr, data_len, data) != hdr_len + data_len)
return -1;
}
} else { /* real broadcast */
/* send the packet using the private network broadcast address */
if (send_pkt(broadcast_addr,
hdr_len, hdr, data_len, data) != hdr_len + data_len)
return -1;
}
return hdr_len+data_len;
}
void send_turn_signal() {
memset(&cf, 0, sizeof(cf));
cf.can_id = signal_id;
cf.len = signal_len;
cf.data[signal_pos] = signal_state;
if(signal_pos) randomize_pkt(0, signal_pos);
if(signal_len != signal_pos + 1) randomize_pkt(signal_pos+1, signal_len);
send_pkt(CAN_MTU);
}
u8 wpan_writeAttr(u8* addr, u8 attr, u32* val)
{
memcpy(ch.addr, addr, WPAN_ADDR_SIZE);
wpan_pkt.header = WPAN_RW;
wpan_pkt.reserve = 0;
WPAN_CMD_TYPE(0) = WPAN_RW_MASK | (attr & WPAN_ATTR_MASK);
WPAN_CMD_DAT(0) = *val;
return send_pkt(&wpan_pkt);
}
/* called when A's timer goes off */
void A_timerinterrupt(void)
{
printf("CCH> A_timerinterrupt> Called\n");
if(last_ack && (last_ack->acknum < last_pkt->seqnum)) {
printf("CCH> A_timerinterrupt> Packet timed out, resending\n");
send_pkt(A, last_pkt);
}
}
void send_unlock(char door) {
door_state &= ~door;
memset(&cf, 0, sizeof(cf));
cf.can_id = door_id;
cf.len = door_len;
cf.data[door_pos] = door_state;
if (door_pos) randomize_pkt(0, door_pos);
if (door_len != door_pos + 1) randomize_pkt(door_pos + 1, door_len);
send_pkt(CAN_MTU);
}
void key_xchg (void)
{
if (init_session()) // initialize session key
{
if (recv_pkt()) // receive public key
{
modexp(); // encrypt the session key
send_pkt(); // send session key
}
}
}
static void
send_pktq(struct pktq *pktq)
{
struct pkt *pkt, *next;
for (pkt = TAILQ_FIRST(pktq); pkt != TAILQ_END(pktq); pkt = next) {
next = TAILQ_NEXT(pkt, pkt_next);
TAILQ_REMOVE(pktq, pkt, pkt_next);
send_pkt(pkt);
}
}
//主循环检测数据包
//返回是否成功处理包，0成功，1失败或无数据
u8 deal_wpan(void) //wpan检查是否有包，及处理
{
if(NRF24L01_IRQ==0) { //收到包
NRF24L01_RxPacket((u8 *)&wpan_pkt); //170us读取
if(deal_pkt(&wpan_pkt)) { //返回1表示读信息，要返回数据//40us
return send_pkt(&wpan_pkt);
}
return 0;
}
return 1;
}
void key_xchg (void)
{
uint8_t buf[2048];
uint32_t keylen=0;
// send public
send_pkt (rsa->n->d, rsa->n->dmax);
// wait for encrypted session key
keylen=recv_pkt (buf, sizeof(buf));
RSA_private_decrypt(keylen, session_key, buf, rsa, RSA_NO_PADDING);
}
int
network_send_pkt(network_address_t dest_address, int hdr_len,
char* hdr, int data_len, char* data)
{
if (synthetic_network) {
if(genrand() < loss_rate) {
if (NETWORK_DEBUG == 1)
printf("Loss by network_send_pkt.\n");
return (hdr_len+data_len);
}
if(genrand() < duplication_rate) {
if (NETWORK_DEBUG == 1)
printf("Duplicate by network_send_pkt.\n");
send_pkt(dest_address, hdr_len, hdr, data_len, data);
}
}
return send_pkt(dest_address, hdr_len, hdr, data_len, data);
}
/**
* Sends a TCP-connection related segment (SYN, FIN, etc.).
*
* dst: A conn_t object associated with the destination.
* flags: TCP flags.
*
* returns: -1 if error, 0 otherwise.
*/
int send_tcp_conn_seg(conn_t *dst, int flags) {
char *tcp_pkt = create_tcp_seg(dst, flags, NULL, 0);
int r = send_pkt(dst, config->socket, tcp_pkt, FULL_HDR_SIZE, 0);
free(tcp_pkt);
if (r < 0) {
fprintf(stderr, "[ERROR] Could not connect\n");
return -1;
}
return 0;
}
static void
dhcp_init_reboot_v4(dhcp_smach_t *dsmp)
{
dhcp_pkt_t *dpkt;
const char *reqhost;
char hostfile[PATH_MAX + 1];
/*
* assemble DHCPREQUEST message. The max dhcp message size
* option is set to the interface max, minus the size of the udp and
* ip headers.
*/
dpkt = init_pkt(dsmp, REQUEST);
(void) add_pkt_opt32(dpkt, CD_REQUESTED_IP_ADDR,
dsmp->dsm_ack->pkt->yiaddr.s_addr);
(void) add_pkt_opt32(dpkt, CD_LEASE_TIME, htonl(DHCP_PERM));
(void) add_pkt_opt16(dpkt, CD_MAX_DHCP_SIZE,
htons(dsmp->dsm_lif->lif_pif->pif_max - sizeof (struct udpiphdr)));
if (class_id_len != 0)
(void) add_pkt_opt(dpkt, CD_CLASS_ID, class_id, class_id_len);
(void) add_pkt_prl(dpkt, dsmp);
/*
* Set CD_HOSTNAME option if REQUEST_HOSTNAME is set and a hostname
* is found in /etc/hostname.<ifname>
*/
if (df_get_bool(dsmp->dsm_name, dsmp->dsm_isv6, DF_REQUEST_HOSTNAME)) {
(void) snprintf(hostfile, sizeof (hostfile), "/etc/hostname.%s",
dsmp->dsm_name);
if ((reqhost = iffile_to_hostname(hostfile)) != NULL) {
dhcpmsg(MSG_DEBUG, "dhcp_selecting: host %s", reqhost);
if ((dsmp->dsm_reqhost = strdup(reqhost)) != NULL)
(void) add_pkt_opt(dpkt, CD_HOSTNAME,
dsmp->dsm_reqhost,
strlen(dsmp->dsm_reqhost));
else
dhcpmsg(MSG_WARNING, "dhcp_selecting: cannot"
" allocate memory for host name option");
} else {
dhcpmsg(MSG_DEBUG,
"dhcp_selecting: no hostname for %s",
dsmp->dsm_name);
}
}
(void) add_pkt_opt(dpkt, CD_END, NULL, 0);
(void) send_pkt(dsmp, dpkt, htonl(INADDR_BROADCAST), stop_init_reboot);
}
/* called from layer 5, passed the data to be sent to other side */
void A_output(struct msg message)
{
printf("CCH> A_output> Got message\n");
struct pkt *out_pkt;
int seqnum;
seqnum = (last_pkt && last_pkt->seqnum < 1) ? 1 : 0;
out_pkt = make_pkt(seqnum, message.data);
last_pkt = out_pkt;
send_pkt(A, out_pkt);
}
void server::remove_from_server(view *f) // should only be called from client side
{
if (f->connect)
{
packet pk;
uint8_t cmd=SCMD_QUIT; // send quit command to server
pk.write(&cmd,1);
send_pkt(f->connect,pk);
delete f->connect;
f->connect=NULL;
}
}
static void forward_response(pkt_t *pkt, uint8_t attempt)
{
int8_t rc;
LOGA("fwd to next hop ");
LOGP("%d ", route_to_origin);
LOGA(" attempt "); LOGP("%u\r\n", attempt);
pkt->dest = route_to_origin;
rc = send_pkt(pkt, TX_FLAG_NONE, NULL);
if (rc != NRK_OK)
LOG("WARN: failed to send discover req\r\n");
}
static int send_plist_pkt(struct mux_client *client, uint32_t tag, plist_t plist)
{
int res = -1;
char *xml = NULL;
uint32_t xmlsize = 0;
plist_to_xml(plist, &xml, &xmlsize);
if (xml) {
res = send_pkt(client, tag, MESSAGE_PLIST, xml, xmlsize);
free(xml);
} else {
usbmuxd_log(LL_ERROR, "%s: Could not convert plist to xml", __func__);
}
return res;
}
static int send_vendor_pkt(struct context *ctx, const uint8_t *to,
uint16_t mmtype, const void *payload, size_t payload_len)
{
struct homeplug_av_vendor_hdr hdr;
memset(&hdr, 0, sizeof(hdr));
hdr.mmver = 0;
hdr.mmtype = mmtype;
hdr.oui[0] = 0x00;
hdr.oui[1] = 0xB0;
hdr.oui[2] = 0x52;
return send_pkt(ctx, to, &hdr, sizeof(hdr), payload, payload_len);
}
void send_speed() {
int kph = (current_speed / 0.6213751) * 100;
memset(&cf, 0, sizeof(cf));
cf.can_id = speed_id;
cf.len = speed_len;
cf.data[speed_pos+1] = (char)kph & 0xff;
cf.data[speed_pos] = (char)(kph >> 8) & 0xff;
if(kph == 0) { // IDLE
cf.data[speed_pos] = 1;
cf.data[speed_pos+1] = rand() % 255+100;
}
if (speed_pos) randomize_pkt(0, speed_pos);
if (speed_len != speed_pos + 2) randomize_pkt(speed_pos+2, speed_len);
send_pkt(CAN_MTU);
}
static int notify_device_remove(struct mux_client *client, uint32_t device_id)
{
int res = -1;
if (client->proto_version == 1) {
/* XML plist packet */
plist_t dict = plist_new_dict();
plist_dict_insert_item(dict, "MessageType", plist_new_string("Detached"));
plist_dict_insert_item(dict, "DeviceID", plist_new_uint(device_id));
res = send_plist_pkt(client, 0, dict);
plist_free(dict);
} else {
/* binary packet */
res = send_pkt(client, 0, MESSAGE_DEVICE_REMOVE, &device_id, sizeof(uint32_t));
}
return res;
}
static int send_result(struct mux_client *client, uint32_t tag, uint32_t result)
{
int res = -1;
if (client->proto_version == 1) {
/* XML plist packet */
plist_t dict = plist_new_dict();
plist_dict_insert_item(dict, "MessageType", plist_new_string("Result"));
plist_dict_insert_item(dict, "Number", plist_new_uint(result));
res = send_plist_pkt(client, tag, dict);
plist_free(dict);
} else {
/* binary packet */
res = send_pkt(client, tag, MESSAGE_RESULT, &result, sizeof(uint32_t));
}
return res;
}
