uint16 BNEP_DISCONNECT_REQ_T_PDU::get_id() const
{
return get_uint16 ( BNEP_DISCONNECT_REQ_T_id );
}
uint16_t gme_game_get_bonus_rounds(const struct gme_game* g) {
assert(g->type==6);
return get_uint16(g->raw);
}
uint16_t gme_game_get_pre_last_round_count(const struct gme_game* g) {
return get_uint16(gme_game_get_last_round_p(g));
}
/* Given a path to a Zip file and a toc_entry, return the (uncompressed)
data as a new reference. */
static PyObject *
get_data(PyObject *archive, PyObject *toc_entry)
{
PyObject *raw_data = NULL, *data, *decompress;
char *buf;
FILE *fp;
PyObject *datapath;
unsigned short compress, time, date;
unsigned int crc;
Py_ssize_t data_size, file_size, bytes_size;
long file_offset, header_size;
unsigned char buffer[30];
const char *errmsg = NULL;
if (!PyArg_ParseTuple(toc_entry, "OHnnlHHI", &datapath, &compress,
&data_size, &file_size, &file_offset, &time,
&date, &crc)) {
return NULL;
}
if (data_size < 0) {
PyErr_Format(ZipImportError, "negative data size");
return NULL;
}
fp = _Py_fopen_obj(archive, "rb");
if (!fp) {
return NULL;
}
/* Check to make sure the local file header is correct */
if (fseek(fp, file_offset, 0) == -1) {
goto file_error;
}
if (fread(buffer, 1, 30, fp) != 30) {
goto eof_error;
}
if (get_uint32(buffer) != 0x04034B50u) {
/* Bad: Local File Header */
errmsg = "bad local file header";
goto invalid_header;
}
header_size = (unsigned int)30 +
get_uint16(buffer + 26) /* file name */ +
get_uint16(buffer + 28) /* extra field */;
if (file_offset > LONG_MAX - header_size) {
errmsg = "bad local file header size";
goto invalid_header;
}
file_offset += header_size; /* Start of file data */
if (data_size > LONG_MAX - 1) {
fclose(fp);
PyErr_NoMemory();
return NULL;
}
bytes_size = compress == 0 ? data_size : data_size + 1;
if (bytes_size == 0) {
bytes_size++;
}
raw_data = PyBytes_FromStringAndSize((char *)NULL, bytes_size);
if (raw_data == NULL) {
goto error;
}
buf = PyBytes_AsString(raw_data);
if (fseek(fp, file_offset, 0) == -1) {
goto file_error;
}
if (fread(buf, 1, data_size, fp) != (size_t)data_size) {
PyErr_SetString(PyExc_IOError,
"zipimport: can't read data");
goto error;
}
fclose(fp);
fp = NULL;
if (compress != 0) {
buf[data_size] = 'Z'; /* saw this in zipfile.py */
data_size++;
}
buf[data_size] = '\0';
if (compress == 0) { /* data is not compressed */
data = PyBytes_FromStringAndSize(buf, data_size);
Py_DECREF(raw_data);
return data;
}
/* Decompress with zlib */
decompress = get_decompress_func();
if (decompress == NULL) {
PyErr_SetString(ZipImportError,
"can't decompress data; "
"zlib not available");
goto error;
}
data = PyObject_CallFunction(decompress, "Oi", raw_data, -15);
Py_DECREF(decompress);
Py_DECREF(raw_data);
return data;
eof_error:
set_file_error(archive, !ferror(fp));
goto error;
file_error:
PyErr_Format(ZipImportError, "can't read Zip file: %R", archive);
goto error;
invalid_header:
assert(errmsg != NULL);
PyErr_Format(ZipImportError, "%s: %R", errmsg, archive);
goto error;
error:
if (fp != NULL) {
fclose(fp);
}
Py_XDECREF(raw_data);
return NULL;
}
/** Respond to an ESTABLISH_INTRO cell by checking the signed data and
* setting the circuit's purpose and service pk digest.
*/
int
rend_mid_establish_intro(or_circuit_t *circ, const uint8_t *request,
size_t request_len)
{
crypto_pk_t *pk = NULL;
char buf[DIGEST_LEN+9];
char expected_digest[DIGEST_LEN];
char pk_digest[DIGEST_LEN];
size_t asn1len;
or_circuit_t *c;
char serviceid[REND_SERVICE_ID_LEN_BASE32+1];
int reason = END_CIRC_REASON_INTERNAL;
log_info(LD_REND,
"Received an ESTABLISH_INTRO request on circuit %u",
(unsigned) circ->p_circ_id);
if (circ->base_.purpose != CIRCUIT_PURPOSE_OR || circ->base_.n_chan) {
log_fn(LOG_PROTOCOL_WARN, LD_PROTOCOL,
"Rejecting ESTABLISH_INTRO on non-OR or non-edge circuit.");
reason = END_CIRC_REASON_TORPROTOCOL;
goto err;
}
if (request_len < 2+DIGEST_LEN)
goto truncated;
/* First 2 bytes: length of asn1-encoded key. */
asn1len = ntohs(get_uint16(request));
/* Next asn1len bytes: asn1-encoded key. */
if (request_len < 2+DIGEST_LEN+asn1len)
goto truncated;
pk = crypto_pk_asn1_decode((char*)(request+2), asn1len);
if (!pk) {
reason = END_CIRC_REASON_TORPROTOCOL;
log_warn(LD_PROTOCOL, "Couldn't decode public key.");
goto err;
}
/* Next 20 bytes: Hash of rend_circ_nonce | "INTRODUCE" */
memcpy(buf, circ->rend_circ_nonce, DIGEST_LEN);
memcpy(buf+DIGEST_LEN, "INTRODUCE", 9);
if (crypto_digest(expected_digest, buf, DIGEST_LEN+9) < 0) {
log_warn(LD_BUG, "Internal error computing digest.");
goto err;
}
if (tor_memneq(expected_digest, request+2+asn1len, DIGEST_LEN)) {
log_warn(LD_PROTOCOL, "Hash of session info was not as expected.");
reason = END_CIRC_REASON_TORPROTOCOL;
goto err;
}
/* Rest of body: signature of previous data */
note_crypto_pk_op(REND_MID);
if (crypto_pk_public_checksig_digest(pk,
(char*)request, 2+asn1len+DIGEST_LEN,
(char*)(request+2+DIGEST_LEN+asn1len),
request_len-(2+DIGEST_LEN+asn1len))<0) {
log_warn(LD_PROTOCOL,
"Incorrect signature on ESTABLISH_INTRO cell; rejecting.");
reason = END_CIRC_REASON_TORPROTOCOL;
goto err;
}
/* The request is valid. First, compute the hash of Bob's PK.*/
if (crypto_pk_get_digest(pk, pk_digest)<0) {
log_warn(LD_BUG, "Internal error: couldn't hash public key.");
goto err;
}
crypto_pk_free(pk); /* don't need it anymore */
pk = NULL; /* so we don't free it again if err */
base32_encode(serviceid, REND_SERVICE_ID_LEN_BASE32+1,
pk_digest, REND_SERVICE_ID_LEN);
/* Close any other intro circuits with the same pk. */
c = NULL;
while ((c = circuit_get_intro_point((const uint8_t *)pk_digest))) {
log_info(LD_REND, "Replacing old circuit for service %s",
safe_str(serviceid));
circuit_mark_for_close(TO_CIRCUIT(c), END_CIRC_REASON_FINISHED);
/* Now it's marked, and it won't be returned next time. */
}
/* Acknowledge the request. */
if (relay_send_command_from_edge(0, TO_CIRCUIT(circ),
RELAY_COMMAND_INTRO_ESTABLISHED,
"", 0, NULL)<0) {
log_info(LD_GENERAL, "Couldn't send INTRO_ESTABLISHED cell.");
goto err;
}
/* Now, set up this circuit. */
circuit_change_purpose(TO_CIRCUIT(circ), CIRCUIT_PURPOSE_INTRO_POINT);
circuit_set_intro_point_digest(circ, (uint8_t *)pk_digest);
log_info(LD_REND,
"Established introduction point on circuit %u for service %s",
(unsigned) circ->p_circ_id, safe_str(serviceid));
return 0;
truncated:
log_warn(LD_PROTOCOL, "Rejecting truncated ESTABLISH_INTRO cell.");
reason = END_CIRC_REASON_TORPROTOCOL;
err:
if (pk) crypto_pk_free(pk);
circuit_mark_for_close(TO_CIRCUIT(circ), reason);
return -1;
}
/*
* handling to receive Notification payload
*/
static int
isakmp_info_recv_n(struct ph1handle *iph1, rc_vchar_t *msg)
{
struct isakmp_pl_n *n = NULL;
unsigned int type;
rc_vchar_t *pbuf;
struct isakmp_parse_t *pa, *pap;
char *spi;
if (!(pbuf = isakmp_parse(msg)))
return -1;
pa = (struct isakmp_parse_t *)pbuf->v;
for (pap = pa; pap->type; pap++) {
switch (pap->type) {
case ISAKMP_NPTYPE_HASH:
/* do something here */
break;
case ISAKMP_NPTYPE_NONCE:
/* send to ack */
break;
case ISAKMP_NPTYPE_N:
n = (struct isakmp_pl_n *)pap->ptr;
break;
default:
rc_vfree(pbuf);
return -1;
}
}
rc_vfree(pbuf);
if (!n)
return -1;
type = get_uint16(&n->type);
switch (type) {
case ISAKMP_NTYPE_CONNECTED:
case ISAKMP_NTYPE_RESPONDER_LIFETIME:
case ISAKMP_NTYPE_REPLAY_STATUS:
/* do something */
break;
case ISAKMP_NTYPE_INITIAL_CONTACT:
info_recv_initialcontact(iph1);
break;
case ISAKMP_NTYPE_R_U_THERE:
isakmp_info_recv_r_u(iph1, (struct isakmp_pl_ru *)n,
((struct isakmp *)msg->v)->msgid);
break;
case ISAKMP_NTYPE_R_U_THERE_ACK:
isakmp_info_recv_r_u_ack(iph1, (struct isakmp_pl_ru *)n,
((struct isakmp *)msg->v)->msgid);
break;
default:
{
uint32_t msgid = ((struct isakmp *)msg->v)->msgid;
struct ph2handle *iph2;
/* XXX there is a potential of dos attack. */
if (msgid == 0) {
/* delete ph1 */
plog(PLOG_PROTOERR, PLOGLOC, 0,
"delete phase1 handle.\n");
return -1;
} else {
iph2 = getph2bymsgid(iph1, msgid);
if (iph2 == NULL) {
plog(PLOG_PROTOERR, PLOGLOC, 0,
"unknown notify message, "
"no phase2 handle found.\n");
} else {
/* delete ph2 */
unbindph12(iph2);
remph2(iph2);
delph2(iph2);
}
}
}
break;
}
/* get spi and allocate */
if (get_uint16(&n->h.len) < sizeof(*n) + n->spi_size) {
plog(PLOG_PROTOERR, PLOGLOC, 0,
"invalid spi_size in notification payload.\n");
return -1;
}
spi = val2str((char *)(n + 1), n->spi_size);
plog(PLOG_DEBUG, PLOGLOC, 0,
"notification message %d:%s, "
"doi=%d proto_id=%d spi=%s(size=%d).\n",
type, s_isakmp_notify_msg(type),
get_uint32(&n->doi), n->proto_id, spi, n->spi_size);
racoon_free(spi);
return(0);
}
void xs::pgm_receiver_t::in_event (fd_t fd_)
{
// Read data from the underlying pgm_socket.
unsigned char *data = NULL;
const pgm_tsi_t *tsi = NULL;
if (pending_bytes > 0)
return;
if (rx_timer) {
rm_timer (rx_timer);
rx_timer = NULL;
}
// TODO: This loop can effectively block other engines in the same I/O
// thread in the case of high load.
while (true) {
// Get new batch of data.
// Note the workaround made not to break strict-aliasing rules.
void *tmp = NULL;
ssize_t received = pgm_socket.receive (&tmp, &tsi);
data = (unsigned char*) tmp;
// No data to process. This may happen if the packet received is
// neither ODATA nor ODATA.
if (received == 0) {
if (errno == ENOMEM || errno == EBUSY) {
const long timeout = pgm_socket.get_rx_timeout ();
xs_assert (!rx_timer);
rx_timer = add_timer (timeout);
}
break;
}
// Find the peer based on its TSI.
peers_t::iterator it = peers.find (*tsi);
// Data loss. Delete decoder and mark the peer as disjoint.
if (received == -1) {
if (it != peers.end ()) {
it->second.joined = false;
if (it->second.decoder == mru_decoder)
mru_decoder = NULL;
if (it->second.decoder != NULL) {
delete it->second.decoder;
it->second.decoder = NULL;
}
}
break;
}
// New peer. Add it to the list of know but unjoint peers.
if (it == peers.end ()) {
peer_info_t peer_info = {false, NULL};
it = peers.insert (peers_t::value_type (*tsi, peer_info)).first;
}
// Read the offset of the fist message in the current packet.
xs_assert ((size_t) received >= sizeof (uint16_t));
uint16_t offset = get_uint16 (data);
data += sizeof (uint16_t);
received -= sizeof (uint16_t);
// Join the stream if needed.
if (!it->second.joined) {
// There is no beginning of the message in current packet.
// Ignore the data.
if (offset == 0xffff)
continue;
xs_assert (offset <= received);
xs_assert (it->second.decoder == NULL);
// We have to move data to the begining of the first message.
data += offset;
received -= offset;
// Mark the stream as joined.
it->second.joined = true;
// Create and connect decoder for the peer.
it->second.decoder = new (std::nothrow) decoder_t (0,
options.maxmsgsize);
alloc_assert (it->second.decoder);
it->second.decoder->set_session (session);
}
mru_decoder = it->second.decoder;
// Push all the data to the decoder.
ssize_t processed = it->second.decoder->process_buffer (data, received);
if (processed < received) {
// Save some state so we can resume the decoding process later.
pending_bytes = received - processed;
pending_ptr = data + processed;
// Stop polling.
reset_pollin (pipe_handle);
reset_pollin (socket_handle);
// Reset outstanding timer.
if (rx_timer) {
rm_timer (rx_timer);
rx_timer = NULL;
}
break;
}
}
// Flush any messages decoder may have produced.
session->flush ();
}
uint16 BNEP_REGISTER_REQ_T_PDU::get_flags() const
{
return get_uint16 ( BNEP_REGISTER_REQ_T_flags );
}
uint16 BNEP_REGISTER_REQ_T_PDU::get_phandle() const
{
return get_uint16 ( BNEP_REGISTER_REQ_T_phandle );
}
uint16 BNEP_CONNECT_IND_T_PDU::get_loc_uuid() const
{
return get_uint16 ( BNEP_CONNECT_IND_T_loc_uuid );
}
uint16 BNEP_CONNECT_REQ_T_PDU::get_flags() const
{
return get_uint16 ( BNEP_CONNECT_REQ_T_flags );
}
uint16 BNEP_CONNECT_IND_T_PDU::get_status() const
{
return get_uint16 ( BNEP_CONNECT_IND_T_status );
}
uint16 BNEP_FLOW_IND_T_PDU::get_free() const
{
return get_uint16 ( BNEP_FLOW_IND_T_free );
}
uint16 BNEP_IGNORE_REQ_T_PDU::get_ether_type() const
{
return get_uint16 ( BNEP_IGNORE_REQ_T_ether_type );
}
/** Unpack <b>tag</b> into addr, port, and circ_id.
*/
static void
tag_unpack(const char *tag, uint64_t *chan_id, circid_t *circ_id)
{
*chan_id = get_uint64(tag);
*circ_id = get_uint16(tag+8);
}
uint16 BNEP_HCI_SWITCH_ROLE_RSP_T_PDU::get_phandle() const
{
return get_uint16 ( BNEP_HCI_SWITCH_ROLE_RSP_T_phandle );
}
/*
* receive Information
*/
int
isakmp_info_recv(struct ph1handle *iph1, rc_vchar_t *msg0)
{
rc_vchar_t *msg = NULL;
struct isakmp *isakmp;
struct isakmp_gen *gen;
void *p;
rc_vchar_t *hash, *payload;
struct isakmp_gen *nd;
uint8_t np;
int encrypted;
plog(PLOG_DEBUG, PLOGLOC, NULL, "receive Information.\n");
encrypted = ISSET(((struct isakmp *)msg0->v)->flags, ISAKMP_FLAG_E);
/* Use new IV to decrypt Informational message. */
if (encrypted) {
struct isakmp_ivm *ivm;
if (iph1->ivm == NULL) {
plog(PLOG_INTERR, PLOGLOC, NULL, "iph1->ivm == NULL\n");
return -1;
}
/* compute IV */
ivm = oakley_newiv2(iph1, ((struct isakmp *)msg0->v)->msgid);
if (ivm == NULL)
return -1;
msg = oakley_do_decrypt(iph1, msg0, ivm->iv, ivm->ive);
oakley_delivm(ivm);
if (msg == NULL)
return -1;
} else
msg = rc_vdup(msg0);
/* Safety check */
if (msg->l < sizeof(*isakmp) + sizeof(*gen)) {
plog(PLOG_PROTOERR, PLOGLOC, NULL,
"ignore information because the "
"message is way too short\n");
goto end;
}
isakmp = (struct isakmp *)msg->v;
gen = (struct isakmp_gen *)((caddr_t)isakmp + sizeof(struct isakmp));
np = gen->np;
if (encrypted) {
if (isakmp->np != ISAKMP_NPTYPE_HASH) {
plog(PLOG_PROTOERR, PLOGLOC, NULL,
"ignore information because the "
"message has no hash payload.\n");
goto end;
}
if (iph1->status != PHASE1ST_ESTABLISHED) {
plog(PLOG_PROTOERR, PLOGLOC, NULL,
"ignore information because ISAKMP-SA "
"has not been established yet.\n");
goto end;
}
/* Safety check */
if (msg->l < sizeof(*isakmp) + get_uint16(&gen->len) + sizeof(*nd)) {
plog(PLOG_PROTOERR, PLOGLOC, NULL,
"ignore information because the "
"message is too short\n");
goto end;
}
p = (caddr_t) gen + sizeof(struct isakmp_gen);
nd = (struct isakmp_gen *) ((caddr_t) gen + get_uint16(&gen->len));
/* nd length check */
if (get_uint16(&nd->len) > msg->l - (sizeof(struct isakmp) +
get_uint16(&gen->len))) {
plog(PLOG_PROTOERR, PLOGLOC, NULL,
"too long payload length (broken message?)\n");
goto end;
}
if (get_uint16(&nd->len) < sizeof(*nd)) {
plog(PLOG_PROTOERR, PLOGLOC, NULL,
"too short payload length (broken message?)\n");
goto end;
}
payload = rc_vmalloc(get_uint16(&nd->len));
if (payload == NULL) {
plog(PLOG_INTERR, PLOGLOC, NULL,
"cannot allocate memory\n");
goto end;
}
memcpy(payload->v, (caddr_t) nd, get_uint16(&nd->len));
/* compute HASH */
hash = oakley_compute_hash1(iph1, isakmp->msgid, payload);
if (hash == NULL) {
plog(PLOG_INTERR, PLOGLOC, NULL,
"cannot compute hash\n");
rc_vfree(payload);
goto end;
}
if (get_uint16(&gen->len) - sizeof(struct isakmp_gen) != hash->l) {
plog(PLOG_PROTOERR, PLOGLOC, NULL,
"ignore information due to hash length mismatch\n");
rc_vfree(hash);
rc_vfree(payload);
goto end;
}
if (memcmp(p, hash->v, hash->l) != 0) {
plog(PLOG_PROTOERR, PLOGLOC, NULL,
"ignore information due to hash mismatch\n");
rc_vfree(hash);
rc_vfree(payload);
goto end;
}
plog(PLOG_DEBUG, PLOGLOC, NULL, "hash validated.\n");
rc_vfree(hash);
rc_vfree(payload);
} else {
/* make sure the packet was encrypted after the beginning of phase 1. */
switch (iph1->etype) {
case ISAKMP_ETYPE_AGG:
case ISAKMP_ETYPE_BASE:
case ISAKMP_ETYPE_IDENT:
if ((iph1->side == INITIATOR && iph1->status < PHASE1ST_MSG3SENT)
|| (iph1->side == RESPONDER && iph1->status < PHASE1ST_MSG2SENT)) {
break;
}
/*FALLTHRU*/
default:
plog(PLOG_PROTOERR, PLOGLOC, 0,
"received %s payload is not encrypted\n",
s_isakmp_nptype(isakmp->np));
goto end;
}
}
switch (np) {
case ISAKMP_NPTYPE_N:
if ( encrypted )
isakmp_info_recv_n(iph1, msg);
else
plog(PLOG_PROTOWARN, PLOGLOC, 0,
"received unencrypted Notify payload, ignored\n");
break;
case ISAKMP_NPTYPE_D:
if ( encrypted )
isakmp_info_recv_d(iph1, msg);
else
plog(PLOG_PROTOWARN, PLOGLOC, 0,
"received unencrypted Delete payload, ignored\n");
break;
case ISAKMP_NPTYPE_NONCE:
/* XXX to be 6.4.2 ike-01.txt */
/* XXX IV is to be synchronized. */
plog(PLOG_PROTOERR, PLOGLOC, 0,
"ignore Acknowledged Informational\n");
break;
default:
/* don't send information, see isakmp_ident_r1() */
plog(PLOG_PROTOERR, PLOGLOC, 0,
"reject the packet, "
"received unexpected payload type %s.\n",
s_isakmp_nptype(gen->np));
goto end;
}
end:
if (msg != NULL)
rc_vfree(msg);
return 0;
}
int
get_target_port_group(struct path * pp, unsigned int timeout)
{
unsigned char *buf;
struct vpd83_data * vpd83;
struct vpd83_dscr * dscr;
int rc;
int buflen, scsi_buflen;
buflen = 4096;
buf = (unsigned char *)malloc(buflen);
if (!buf) {
PRINT_DEBUG("malloc failed: could not allocate"
"%u bytes\n", buflen);
return -RTPG_RTPG_FAILED;
}
memset(buf, 0, buflen);
rc = get_sysfs_pg83(pp, buf, buflen);
if (rc < 0) {
rc = do_inquiry(pp->fd, 1, 0x83, buf, buflen, timeout);
if (rc < 0)
goto out;
scsi_buflen = (buf[2] << 8 | buf[3]) + 4;
/* Paranoia */
if (scsi_buflen >= USHRT_MAX)
scsi_buflen = USHRT_MAX;
if (buflen < scsi_buflen) {
free(buf);
buf = (unsigned char *)malloc(scsi_buflen);
if (!buf) {
PRINT_DEBUG("malloc failed: could not allocate"
"%u bytes\n", scsi_buflen);
return -RTPG_RTPG_FAILED;
}
buflen = scsi_buflen;
memset(buf, 0, buflen);
rc = do_inquiry(pp->fd, 1, 0x83, buf, buflen, timeout);
if (rc < 0)
goto out;
}
}
vpd83 = (struct vpd83_data *) buf;
rc = -RTPG_NO_TPG_IDENTIFIER;
FOR_EACH_VPD83_DSCR(vpd83, dscr) {
if (vpd83_dscr_istype(dscr, IDTYPE_TARGET_PORT_GROUP)) {
struct vpd83_tpg_dscr *p;
if (rc != -RTPG_NO_TPG_IDENTIFIER) {
PRINT_DEBUG("get_target_port_group: more "
"than one TPG identifier found!\n");
continue;
}
p = (struct vpd83_tpg_dscr *)dscr->data;
rc = get_uint16(p->tpg);
}
}
if (rc == -RTPG_NO_TPG_IDENTIFIER) {
PRINT_DEBUG("get_target_port_group: "
"no TPG identifier found!\n");
}
out:
free(buf);
return rc;
}
void zmq::pgm_receiver_t::in_event ()
{
// Read data from the underlying pgm_socket.
unsigned char *data = NULL;
const pgm_tsi_t *tsi = NULL;
// TODO: This loop can effectively block other engines in the same I/O
// thread in the case of high load.
while (true) {
// Get new batch of data.
ssize_t received = pgm_socket.receive ((void**) &data, &tsi);
// No data to process. This may happen if the packet received is
// neither ODATA nor ODATA.
if (received == 0)
break;
// Find the peer based on its TSI.
peers_t::iterator it = peers.find (*tsi);
// Data loss. Delete decoder and mark the peer as disjoint.
if (received == -1) {
zmq_assert (it != peers.end ());
it->second.joined = false;
if (it->second.decoder != NULL) {
delete it->second.decoder;
it->second.decoder = NULL;
}
break;
}
// New peer. Add it to the list of know but unjoint peers.
if (it == peers.end ()) {
peer_info_t peer_info = {false, NULL};
it = peers.insert (std::make_pair (*tsi, peer_info)).first;
}
// Read the offset of the fist message in the current packet.
zmq_assert ((size_t) received >= sizeof (uint16_t));
uint16_t offset = get_uint16 (data);
data += sizeof (uint16_t);
received -= sizeof (uint16_t);
// Join the stream if needed.
if (!it->second.joined) {
// There is no beginning of the message in current packet.
// Ignore the data.
if (offset == 0xffff)
continue;
zmq_assert (offset <= received);
zmq_assert (it->second.decoder == NULL);
// We have to move data to the begining of the first message.
data += offset;
received -= offset;
// Mark the stream as joined.
it->second.joined = true;
// Create and connect decoder for the peer.
it->second.decoder = new (std::nothrow) zmq_decoder_t (0, NULL, 0);
it->second.decoder->set_inout (inout);
}
// Push all the data to the decoder.
// TODO: process_buffer may not process entire buffer!
ssize_t processed = it->second.decoder->process_buffer (data, received);
zmq_assert (processed == received);
}
// Flush any messages decoder may have produced.
inout->flush ();
}
void zmq::pgm_receiver_t::in_event ()
{
// Read data from the underlying pgm_socket.
const pgm_tsi_t *tsi = NULL;
if (has_rx_timer) {
cancel_timer (rx_timer_id);
has_rx_timer = false;
}
// TODO: This loop can effectively block other engines in the same I/O
// thread in the case of high load.
while (true) {
// Get new batch of data.
// Note the workaround made not to break strict-aliasing rules.
void *tmp = NULL;
ssize_t received = pgm_socket.receive (&tmp, &tsi);
inpos = (unsigned char*) tmp;
// No data to process. This may happen if the packet received is
// neither ODATA nor ODATA.
if (received == 0) {
if (errno == ENOMEM || errno == EBUSY) {
const long timeout = pgm_socket.get_rx_timeout ();
add_timer (timeout, rx_timer_id);
has_rx_timer = true;
}
break;
}
// Find the peer based on its TSI.
peers_t::iterator it = peers.find (*tsi);
// Data loss. Delete decoder and mark the peer as disjoint.
if (received == -1) {
if (it != peers.end ()) {
it->second.joined = false;
if (it->second.decoder != NULL) {
delete it->second.decoder;
it->second.decoder = NULL;
}
}
break;
}
// New peer. Add it to the list of know but unjoint peers.
if (it == peers.end ()) {
peer_info_t peer_info = {false, NULL};
it = peers.insert (peers_t::value_type (*tsi, peer_info)).first;
}
insize = static_cast <size_t> (received);
// Read the offset of the fist message in the current packet.
zmq_assert (insize >= sizeof (uint16_t));
uint16_t offset = get_uint16 (inpos);
inpos += sizeof (uint16_t);
insize -= sizeof (uint16_t);
// Join the stream if needed.
if (!it->second.joined) {
// There is no beginning of the message in current packet.
// Ignore the data.
if (offset == 0xffff)
continue;
zmq_assert (offset <= insize);
zmq_assert (it->second.decoder == NULL);
// We have to move data to the begining of the first message.
inpos += offset;
insize -= offset;
// Mark the stream as joined.
it->second.joined = true;
// Create and connect decoder for the peer.
it->second.decoder = new (std::nothrow)
v1_decoder_t (0, options.maxmsgsize);
alloc_assert (it->second.decoder);
}
int rc = process_input (it->second.decoder);
if (rc == -1) {
if (errno == EAGAIN) {
active_tsi = tsi;
// Stop polling.
reset_pollin (pipe_handle);
reset_pollin (socket_handle);
break;
}
it->second.joined = false;
delete it->second.decoder;
it->second.decoder = NULL;
insize = 0;
}
}
// Flush any messages decoder may have produced.
session->flush ();
}
/* Process a buffer of PCL XL commands. */
int
px_process(px_parser_state_t * st, px_state_t * pxs, stream_cursor_read * pr)
{
const byte *orig_p = pr->ptr;
const byte *next_p = orig_p; /* start of data not copied to saved */
const byte *p;
const byte *rlimit;
px_value_t *sp = &st->stack[st->stack_count];
#define stack_limit &st->stack[max_stack - 1]
gs_memory_t *memory = st->memory;
int code = 0;
uint left;
uint min_left;
px_tag_t tag;
const px_tag_syntax_t *syntax = 0;
st->args.parser = st;
st->parent_operator_count = 0; /* in case of error */
/* Check for leftover data from the previous call. */
parse:if (st->saved_count) { /* Fill up the saved buffer so we can make progress. */
int move = min(sizeof(st->saved) - st->saved_count,
pr->limit - next_p);
memcpy(&st->saved[st->saved_count], next_p + 1, move);
next_p += move;
p = st->saved - 1;
rlimit = p + st->saved_count + move;
} else { /* No leftover data, just read from the input. */
p = next_p;
rlimit = pr->limit;
}
top:if (st->data_left) { /* We're in the middle of reading an array or data block. */
if (st->data_proc) { /* This is a data block. */
uint avail = min(rlimit - p, st->data_left);
uint used;
st->args.source.available = avail;
st->args.source.data = p + 1;
code = (*st->data_proc) (&st->args, pxs);
/* If we get a 'remap_color' error, it means we are dealing with a
* pattern, and the device supports high level patterns. So we must
* use our high level pattern implementation.
*/
if (code == gs_error_Remap_Color) {
code = px_high_level_pattern(pxs->pgs);
code = (*st->data_proc) (&st->args, pxs);
}
used = st->args.source.data - (p + 1);
#ifdef DEBUG
if (gs_debug_c('I')) {
px_value_t data_array;
data_array.type = pxd_ubyte;
data_array.value.array.data = p + 1;
data_array.value.array.size = used;
trace_array_data(pxs->memory, "data:", &data_array);
}
#endif
p = st->args.source.data - 1;
st->data_left -= used;
if (code < 0) {
st->args.source.position = 0;
goto x;
} else if ((code == pxNeedData)
|| (code == pxPassThrough && st->data_left != 0)) {
code = 0; /* exit for more data */
goto x;
} else {
st->args.source.position = 0;
st->data_proc = 0;
if (st->data_left != 0) {
code = gs_note_error(errorExtraData);
goto x;
}
clear_stack();
}
} else { /* This is an array. */
uint size = sp->value.array.size;
uint scale = value_size(sp);
uint nbytes = size * scale;
byte *dest =
(byte *) sp->value.array.data + nbytes - st->data_left;
left = rlimit - p;
if (left < st->data_left) { /* We still don't have enough data to fill the array. */
memcpy(dest, p + 1, left);
st->data_left -= left;
p = rlimit;
code = 0;
goto x;
}
/* Complete the array and continue parsing. */
memcpy(dest, p + 1, st->data_left);
trace_array(memory, sp);
p += st->data_left;
}
st->data_left = 0;
} else if (st->data_proc) { /* An operator is awaiting data. */
/* Skip white space until we find some. */
code = 0; /* in case we exit */
/* special case - VendorUnique has a length attribute which
we've already parsed and error checked */
if (st->data_proc == pxVendorUnique) {
st->data_left =
st->stack[st->attribute_indices[pxaVUDataLength]].value.i;
goto top;
} else {
while ((left = rlimit - p) != 0) {
switch ((tag = p[1])) {
case pxtNull:
case pxtHT:
case pxtLF:
case pxtVT:
case pxtFF:
case pxtCR:
++p;
continue;
case pxt_dataLength:
if (left < 5)
goto x; /* can't look ahead */
st->data_left = get_uint32(st, p + 2);
if_debug2m('i', memory, "tag= 0x%2x data, length %u\n",
p[1], st->data_left);
p += 5;
goto top;
case pxt_dataLengthByte:
if (left < 2)
goto x; /* can't look ahead */
st->data_left = p[2];
if_debug2m('i', memory, "tag= 0x%2x data, length %u\n",
p[1], st->data_left);
p += 2;
goto top;
default:
{
code = gs_note_error(errorMissingData);
goto x;
}
}
}
}
}
st->args.source.position = 0;
st->args.source.available = 0;
while ((left = rlimit - p) != 0 &&
left >= (min_left = (syntax = &tag_syntax[tag = p[1]])->min_input)
) {
int count;
#ifdef DEBUG
if (gs_debug_c('i')) {
dmprintf1(memory, "tag= 0x%02x ", tag);
if (tag == pxt_attr_ubyte || tag == pxt_attr_uint16) {
px_attribute_t attr =
(tag == pxt_attr_ubyte ? p[2] : get_uint16(st, p + 2));
const char *aname = px_attribute_names[attr];
if (aname)
dmprintf1(memory, " @%s\n", aname);
else
dmprintf1(memory, " attribute %u ???\n", attr);
} else {
const char *format;
const char *tname;
bool operator = false;
if (tag < 0x40)
format = "%s\n", tname = px_tag_0_names[tag];
else if (tag < 0xc0)
format = "%s", tname = px_operator_names[tag - 0x40],
operator = true;
else {
tname = px_tag_c0_names[tag - 0xc0];
if (tag < 0xf0)
format = " %s"; /* data values follow */
else
format = "%s\n";
}
if (tname) {
dmprintf1(memory, format, tname);
if (operator)
dmprintf1(memory, " (%ld)\n", st->operator_count + 1);
} else
dmputs(memory, "???\n");
}
}
#endif
if ((st->macro_state & syntax->state_mask) != syntax->state_value) {
/*
* We should probably distinguish here between
* out-of-context operators and illegal tags, but it's too
* much trouble.
*/
code = gs_note_error(errorIllegalOperatorSequence);
if (tag >= 0x40 && tag < 0xc0)
st->last_operator = tag;
goto x;
}
st->macro_state ^= syntax->state_transition;
switch (tag >> 3) {
case 0:
switch (tag) {
case pxtNull:
++p;
continue;
default:
break;
}
break;
case 1:
switch (tag) {
case pxtHT:
case pxtLF:
case pxtVT:
case pxtFF:
case pxtCR:
++p;
continue;
default:
break;
}
break;
case 3:
if (tag == pxt1b) { /* ESC *//* Check for UEL */
if (memcmp(p + 1, "\033%-12345X", min(left, 9)))
break; /* not UEL, error */
if (left < 9)
goto x; /* need more data */
p += 9;
code = e_ExitLanguage;
goto x;
}
break;
case 4:
switch (tag) {
case pxtSpace:
/* break; will error, compatible with lj */
/* ++p;continue; silently ignores the space */
++p;
continue;
default:
break;
}
break;
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
case 19:
case 20:
case 21:
case 22:
case 23:
/* Operators */
/* Make sure that we have all the required attributes, */
/* and no attributes that are neither required nor */
/* optional. (It's up to the operator to make any */
/* more precise checks than this. */
st->operator_count++;
/* if this is a passthrough operator we have to tell
the passthrough module if this operator was
preceded by another passthrough operator or a
different xl operator */
if (tag == pxtPassThrough) {
pxpcl_passthroughcontiguous(st->last_operator == tag);
} else if (st->last_operator == pxtPassThrough) {
pxpcl_endpassthroughcontiguous(pxs);
}
st->last_operator = tag;
{
const px_operator_definition_t *pod =
&px_operator_definitions[tag - 0x40];
int left = sp - st->stack;
const byte /*px_attribute_t */ * pal = pod->attrs;
px_value_t **ppv = st->args.pv;
bool required = true;
code = 0;
/*
* Scan the attributes. Illegal attributes take priority
* over missing attributes, which in turn take priority
* over illegal data types.
*/
for (;; ++pal, ++ppv) {
px_attribute_t attr = *pal;
uint index;
if (!attr) { /*
* We've reached the end of either the required or
* the optional attribute list.
*/
if (!required)
break;
required = false;
--ppv; /* cancel incrementing */
continue;
}
if ((index = st->attribute_indices[attr]) == 0) {
if (required)
code = gs_note_error(errorMissingAttribute);
else
*ppv = 0;
} else { /* Check the attribute data type and value. */
px_value_t *pv = *ppv = &st->stack[index];
const px_attr_value_type_t *pavt =
&px_attr_value_types[attr];
int acode;
if ((~pavt->mask & pv->type &
(pxd_structure | pxd_representation)) ||
(pavt->mask == (pxd_scalar | pxd_ubyte) &&
(pv->value.i < 0
|| pv->value.i > pavt->limit))
) {
if (code >= 0)
code =
gs_note_error
(errorIllegalAttributeDataType);
}
if (pavt->proc != 0
&& (acode = (*pavt->proc) (pv)) < 0) {
if (code >= 0)
code = acode;
}
--left;
}
}
/* Make sure there are no attributes left over. */
if (left)
code = gs_note_error(errorIllegalAttribute);
if (code >= 0) {
st->args.source.phase = 0;
code = (*pod->proc) (&st->args, pxs);
/* If we get a 'remap_color' error, it means we are dealing with a
* pattern, and the device supports high level patterns. So we must
* use our high level pattern implementation.
*/
if (code == gs_error_Remap_Color) {
code = px_high_level_pattern(pxs->pgs);
if (code < 0)
goto x;
code = (*pod->proc) (&st->args, pxs);
}
}
if (code < 0)
goto x;
/* Check whether the operator wanted source data. */
if (code == pxNeedData) {
if (!pxs->data_source_open) {
code = gs_note_error(errorDataSourceNotOpen);
goto x;
}
st->data_proc = pod->proc;
++p;
goto top;
}
}
clear_stack();
++p;
continue;
case 24:
sp[1].type = pxd_scalar;
count = 1;
goto data;
case 26:
sp[1].type = pxd_xy;
count = 2;
goto data;
case 28:
sp[1].type = pxd_box;
count = 4;
goto data;
/* Scalar, point, and box data */
data:{
int i;
if (sp == stack_limit) {
code = gs_note_error(errorInternalOverflow);
goto x;
}
++sp;
sp->attribute = 0;
p += 2;
#ifdef DEBUG
# define trace_scalar(mem, format, cast, alt)\
if ( gs_debug_c('i') )\
trace_data(mem, format, cast, sp->value.alt, count)
#else
# define trace_scalar(mem, format, cast, alt) DO_NOTHING
#endif
switch (tag & 7) {
case pxt_ubyte & 7:
sp->type |= pxd_ubyte;
for (i = 0; i < count; ++p, ++i)
sp->value.ia[i] = *p;
dux:trace_scalar(pxs->memory, " %lu", ulong,
ia);
--p;
continue;
case pxt_uint16 & 7:
sp->type |= pxd_uint16;
for (i = 0; i < count; p += 2, ++i)
sp->value.ia[i] = get_uint16(st, p);
goto dux;
case pxt_uint32 & 7:
sp->type |= pxd_uint32;
for (i = 0; i < count; p += 4, ++i)
sp->value.ia[i] = get_uint32(st, p);
goto dux;
case pxt_sint16 & 7:
sp->type |= pxd_sint16;
for (i = 0; i < count; p += 2, ++i)
sp->value.ia[i] = get_sint16(st, p);
dsx:trace_scalar(pxs->memory, " %ld", long,
ia);
--p;
continue;
case pxt_sint32 & 7:
sp->type |= pxd_sint32;
for (i = 0; i < count; p += 4, ++i)
sp->value.ia[i] = get_sint32(st, p);
goto dsx;
case pxt_real32 & 7:
sp->type |= pxd_real32;
for (i = 0; i < count; p += 4, ++i)
sp->value.ra[i] = get_real32(st, p);
trace_scalar(pxs->memory, " %g", double, ra);
--p;
continue;
default:
break;
}
}
break;
case 25:
/* Array data */
{
const byte *dp;
uint nbytes;
if (sp == stack_limit) {
code = gs_note_error(errorInternalOverflow);
goto x;
}
switch (p[2]) {
case pxt_ubyte:
sp[1].value.array.size = p[3];
dp = p + 4;
break;
case pxt_uint16:
if (left < 4) {
if_debug0m('i', memory, "...\n");
/* Undo the state transition. */
st->macro_state ^= syntax->state_transition;
goto x;
}
sp[1].value.array.size = get_uint16(st, p + 3);
dp = p + 5;
break;
default:
st->last_operator = tag; /* for error message */
code = gs_note_error(errorIllegalTag);
goto x;
}
nbytes = sp[1].value.array.size;
if_debug1m('i', memory, "[%u]\n", sp[1].value.array.size);
switch (tag) {
case pxt_ubyte_array:
sp[1].type = pxd_array | pxd_ubyte;
array:++sp;
if (st->big_endian)
sp->type |= pxd_big_endian;
sp->value.array.data = dp;
sp->attribute = 0;
/* Check whether we have enough data for the entire */
/* array. */
if (rlimit + 1 - dp < nbytes) { /* Exit now, continue reading when we return. */
uint avail = rlimit + 1 - dp;
code = px_save_array(sp, pxs, "partial array",
avail);
if (code < 0)
goto x;
sp->type |= pxd_on_heap;
st->data_left = nbytes - avail;
st->data_proc = 0;
p = rlimit;
goto x;
}
p = dp + nbytes - 1;
trace_array(memory, sp);
continue;
case pxt_uint16_array:
sp[1].type = pxd_array | pxd_uint16;
a16:nbytes <<= 1;
goto array;
case pxt_uint32_array:
sp[1].type = pxd_array | pxd_uint32;
a32:nbytes <<= 2;
goto array;
case pxt_sint16_array:
sp[1].type = pxd_array | pxd_sint16;
goto a16;
case pxt_sint32_array:
sp[1].type = pxd_array | pxd_sint32;
goto a32;
case pxt_real32_array:
sp[1].type = pxd_array | pxd_real32;
goto a32;
default:
break;
}
break;
}
break;
case 31:
{
px_attribute_t attr;
const byte *pnext;
switch (tag) {
case pxt_attr_ubyte:
attr = p[2];
pnext = p + 2;
goto a;
case pxt_attr_uint16:
attr = get_uint16(st, p + 2);
pnext = p + 3;
a:if (attr >=
px_attribute_next)
break;
/*
* We could check the attribute value type here, but
* in order to match the behavior of the H-P printers,
* we don't do it until we see the operator.
*
* It is legal to specify the same attribute more than
* once; the last value has priority. If this happens,
* since the order of attributes doesn't matter, we can
* just replace the former value on the stack.
*/
sp->attribute = attr;
if (st->attribute_indices[attr] != 0) {
px_value_t *old_sp =
&st->stack[st->attribute_indices[attr]];
/* If the old value is on the heap, free it. */
if (old_sp->type & pxd_on_heap)
gs_free_object(memory,
(void *)old_sp->value.
array.data,
"old value for duplicate attribute");
*old_sp = *sp--;
} else
st->attribute_indices[attr] = sp - st->stack;
p = pnext;
continue;
case pxt_dataLength:
/*
* Unexpected data length operators are normally not
* allowed, but there might be a zero-length data
* block immediately following a zero-size image,
* which doesn't ask for any data.
*/
if (uint32at(p + 2, true /*arbitrary */ ) == 0) {
p += 5;
continue;
}
break;
case pxt_dataLengthByte:
/* See the comment under pxt_dataLength above. */
if (p[2] == 0) {
p += 2;
continue;
}
break;
default:
break;
}
}
break;
default:
break;
}
/* Unknown tag value. Report an error. */
st->last_operator = tag; /* for error message */
code = gs_note_error(errorIllegalTag);
break;
}
x: /* Save any leftover input. */
left = rlimit - p;
if (rlimit != pr->limit) { /* We were reading saved input. */
if (left <= next_p - orig_p) { /* We finished reading the previously saved input. */
/* Continue reading current input, unless we got an error. */
p = next_p -= left;
rlimit = pr->limit;
st->saved_count = 0;
if (code >= 0)
goto parse;
} else { /* There's still some previously saved input left over. */
memmove(st->saved, p + 1, st->saved_count = left);
p = next_p;
rlimit = pr->limit;
left = rlimit - p;
}
}
/* Except in case of error, save any remaining input. */
if (code >= 0) {
if (left + st->saved_count > sizeof(st->saved)) { /* Fatal error -- shouldn't happen! */
code = gs_note_error(errorInternalOverflow);
st->saved_count = 0;
} else {
memcpy(&st->saved[st->saved_count], p + 1, left);
st->saved_count += left;
p = rlimit;
}
}
pr->ptr = p;
st->stack_count = sp - st->stack;
/* Move to the heap any arrays whose data was being referenced */
/* directly in the input buffer. */
for (; sp > st->stack; --sp)
if ((sp->type & (pxd_array | pxd_on_heap)) == pxd_array) {
int code = px_save_array(sp, pxs, "px stack array to heap",
sp->value.array.size * value_size(sp));
if (code < 0)
break;
sp->type |= pxd_on_heap;
}
if (code < 0 && syntax != 0) { /* Undo the state transition. */
st->macro_state ^= syntax->state_transition;
}
return code;
}
uint16_t sonyPS2_buttonsRaw(const SONY_PS2* controller){
uint16_t rtn = get_uint16(controller->buffer,0);
return rtn ^= 0xFFFFU; // invert the bits
}
/*
read_directory(archive) -> files dict (new reference)
Given a path to a Zip archive, build a dict, mapping file names
(local to the archive, using SEP as a separator) to toc entries.
A toc_entry is a tuple:
(__file__, # value to use for __file__, available for all files,
# encoded to the filesystem encoding
compress, # compression kind; 0 for uncompressed
data_size, # size of compressed data on disk
file_size, # size of decompressed data
file_offset, # offset of file header from start of archive
time, # mod time of file (in dos format)
date, # mod data of file (in dos format)
crc, # crc checksum of the data
)
Directories can be recognized by the trailing SEP in the name,
data_size and file_offset are 0.
*/
static PyObject *
read_directory(PyObject *archive)
{
PyObject *files = NULL;
FILE *fp;
unsigned short flags, compress, time, date, name_size;
unsigned int crc, data_size, file_size, header_size, header_offset;
unsigned long file_offset, header_position;
unsigned long arc_offset; /* Absolute offset to start of the zip-archive. */
unsigned int count, i;
unsigned char buffer[46];
char name[MAXPATHLEN + 5];
PyObject *nameobj = NULL;
PyObject *path;
const char *charset;
int bootstrap;
const char *errmsg = NULL;
fp = _Py_fopen_obj(archive, "rb");
if (fp == NULL) {
if (PyErr_ExceptionMatches(PyExc_OSError)) {
_PyErr_FormatFromCause(ZipImportError,
"can't open Zip file: %R", archive);
}
return NULL;
}
if (fseek(fp, -22, SEEK_END) == -1) {
goto file_error;
}
header_position = (unsigned long)ftell(fp);
if (header_position == (unsigned long)-1) {
goto file_error;
}
assert(header_position <= (unsigned long)LONG_MAX);
if (fread(buffer, 1, 22, fp) != 22) {
goto file_error;
}
if (get_uint32(buffer) != 0x06054B50u) {
/* Bad: End of Central Dir signature */
errmsg = "not a Zip file";
goto invalid_header;
}
header_size = get_uint32(buffer + 12);
header_offset = get_uint32(buffer + 16);
if (header_position < header_size) {
errmsg = "bad central directory size";
goto invalid_header;
}
if (header_position < header_offset) {
errmsg = "bad central directory offset";
goto invalid_header;
}
if (header_position - header_size < header_offset) {
errmsg = "bad central directory size or offset";
goto invalid_header;
}
header_position -= header_size;
arc_offset = header_position - header_offset;
files = PyDict_New();
if (files == NULL) {
goto error;
}
/* Start of Central Directory */
count = 0;
if (fseek(fp, (long)header_position, 0) == -1) {
goto file_error;
}
for (;;) {
PyObject *t;
size_t n;
int err;
n = fread(buffer, 1, 46, fp);
if (n < 4) {
goto eof_error;
}
/* Start of file header */
if (get_uint32(buffer) != 0x02014B50u) {
break; /* Bad: Central Dir File Header */
}
if (n != 46) {
goto eof_error;
}
flags = get_uint16(buffer + 8);
compress = get_uint16(buffer + 10);
time = get_uint16(buffer + 12);
date = get_uint16(buffer + 14);
crc = get_uint32(buffer + 16);
data_size = get_uint32(buffer + 20);
file_size = get_uint32(buffer + 24);
name_size = get_uint16(buffer + 28);
header_size = (unsigned int)name_size +
get_uint16(buffer + 30) /* extra field */ +
get_uint16(buffer + 32) /* comment */;
file_offset = get_uint32(buffer + 42);
if (file_offset > header_offset) {
errmsg = "bad local header offset";
goto invalid_header;
}
file_offset += arc_offset;
if (name_size > MAXPATHLEN) {
name_size = MAXPATHLEN;
}
if (fread(name, 1, name_size, fp) != name_size) {
goto file_error;
}
name[name_size] = '\0'; /* Add terminating null byte */
if (SEP != '/') {
for (i = 0; i < name_size; i++) {
if (name[i] == '/') {
name[i] = SEP;
}
}
}
/* Skip the rest of the header.
* On Windows, calling fseek to skip over the fields we don't use is
* slower than reading the data because fseek flushes stdio's
* internal buffers. See issue #8745. */
assert(header_size <= 3*0xFFFFu);
for (i = name_size; i < header_size; i++) {
if (getc(fp) == EOF) {
goto file_error;
}
}
bootstrap = 0;
if (flags & 0x0800) {
charset = "utf-8";
}
else if (!PyThreadState_GET()->interp->codecs_initialized) {
/* During bootstrap, we may need to load the encodings
package from a ZIP file. But the cp437 encoding is implemented
in Python in the encodings package.
Break out of this dependency by assuming that the path to
the encodings module is ASCII-only. */
charset = "ascii";
bootstrap = 1;
}
else {
charset = "cp437";
}
nameobj = PyUnicode_Decode(name, name_size, charset, NULL);
if (nameobj == NULL) {
if (bootstrap) {
PyErr_Format(PyExc_NotImplementedError,
"bootstrap issue: python%i%i.zip contains non-ASCII "
"filenames without the unicode flag",
PY_MAJOR_VERSION, PY_MINOR_VERSION);
}
goto error;
}
if (PyUnicode_READY(nameobj) == -1) {
goto error;
}
path = PyUnicode_FromFormat("%U%c%U", archive, SEP, nameobj);
if (path == NULL) {
goto error;
}
t = Py_BuildValue("NHIIkHHI", path, compress, data_size,
file_size, file_offset, time, date, crc);
if (t == NULL) {
goto error;
}
err = PyDict_SetItem(files, nameobj, t);
Py_CLEAR(nameobj);
Py_DECREF(t);
if (err != 0) {
goto error;
}
count++;
}
fclose(fp);
if (Py_VerboseFlag) {
PySys_FormatStderr("# zipimport: found %u names in %R\n",
count, archive);
}
return files;
eof_error:
set_file_error(archive, !ferror(fp));
goto error;
file_error:
PyErr_Format(ZipImportError, "can't read Zip file: %R", archive);
goto error;
invalid_header:
assert(errmsg != NULL);
PyErr_Format(ZipImportError, "%s: %R", errmsg, archive);
goto error;
error:
fclose(fp);
Py_XDECREF(files);
Py_XDECREF(nameobj);
return NULL;
}
/** Parse an EXTEND or EXTEND2 cell (according to <b>command</b>) from the
* <b>payload_length</b> bytes of <b>payload</b> into <b>cell_out</b>. Return
* 0 on success, -1 on failure. */
int
extend_cell_parse(extend_cell_t *cell_out, const uint8_t command,
const uint8_t *payload, size_t payload_length)
{
const uint8_t *eop;
memset(cell_out, 0, sizeof(*cell_out));
if (payload_length > RELAY_PAYLOAD_SIZE)
return -1;
eop = payload + payload_length;
switch (command) {
case RELAY_COMMAND_EXTEND:
{
if (payload_length != 6 + TAP_ONIONSKIN_CHALLENGE_LEN + DIGEST_LEN)
return -1;
cell_out->cell_type = RELAY_COMMAND_EXTEND;
tor_addr_from_ipv4n(&cell_out->orport_ipv4.addr, get_uint32(payload));
cell_out->orport_ipv4.port = ntohs(get_uint16(payload+4));
tor_addr_make_unspec(&cell_out->orport_ipv6.addr);
if (tor_memeq(payload + 6, NTOR_CREATE_MAGIC, 16)) {
cell_out->create_cell.cell_type = CELL_CREATE2;
cell_out->create_cell.handshake_type = ONION_HANDSHAKE_TYPE_NTOR;
cell_out->create_cell.handshake_len = NTOR_ONIONSKIN_LEN;
memcpy(cell_out->create_cell.onionskin, payload + 22,
NTOR_ONIONSKIN_LEN);
} else {
cell_out->create_cell.cell_type = CELL_CREATE;
cell_out->create_cell.handshake_type = ONION_HANDSHAKE_TYPE_TAP;
cell_out->create_cell.handshake_len = TAP_ONIONSKIN_CHALLENGE_LEN;
memcpy(cell_out->create_cell.onionskin, payload + 6,
TAP_ONIONSKIN_CHALLENGE_LEN);
}
memcpy(cell_out->node_id, payload + 6 + TAP_ONIONSKIN_CHALLENGE_LEN,
DIGEST_LEN);
break;
}
case RELAY_COMMAND_EXTEND2:
{
uint8_t n_specs, spectype, speclen;
int i;
int found_ipv4 = 0, found_ipv6 = 0, found_id = 0;
tor_addr_make_unspec(&cell_out->orport_ipv4.addr);
tor_addr_make_unspec(&cell_out->orport_ipv6.addr);
if (payload_length == 0)
return -1;
cell_out->cell_type = RELAY_COMMAND_EXTEND2;
n_specs = *payload++;
/* Parse the specifiers. We'll only take the first IPv4 and first IPv6
* address, and the node ID, and ignore everything else */
for (i = 0; i < n_specs; ++i) {
if (eop - payload < 2)
return -1;
spectype = payload[0];
speclen = payload[1];
payload += 2;
if (eop - payload < speclen)
return -1;
switch (spectype) {
case SPECTYPE_IPV4:
if (speclen != 6)
return -1;
if (!found_ipv4) {
tor_addr_from_ipv4n(&cell_out->orport_ipv4.addr,
get_uint32(payload));
cell_out->orport_ipv4.port = ntohs(get_uint16(payload+4));
found_ipv4 = 1;
}
break;
case SPECTYPE_IPV6:
if (speclen != 18)
return -1;
if (!found_ipv6) {
tor_addr_from_ipv6_bytes(&cell_out->orport_ipv6.addr,
(const char*)payload);
cell_out->orport_ipv6.port = ntohs(get_uint16(payload+16));
found_ipv6 = 1;
}
break;
case SPECTYPE_LEGACY_ID:
if (speclen != 20)
return -1;
if (found_id)
return -1;
memcpy(cell_out->node_id, payload, 20);
found_id = 1;
break;
}
payload += speclen;
}
if (!found_id || !found_ipv4)
return -1;
if (parse_create2_payload(&cell_out->create_cell,payload,eop-payload)<0)
return -1;
break;
}
default:
return -1;
}
return check_extend_cell(cell_out);
}
static int _set_res_rec(int *start, int argc, char *argv[],
List name_list, List cluster_list,
slurmdb_res_rec_t *res)
{
int i;
int set = 0;
int end = 0;
int command_len = 0;
int option = 0;
xassert(res);
for (i=(*start); i<argc; i++) {
end = parse_option_end(argv[i]);
if (!end)
command_len=strlen(argv[i]);
else {
command_len=end-1;
if (argv[i][end] == '=') {
option = (int)argv[i][end-1];
end++;
}
}
if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))) {
i--;
break;
} else if (!end && !strncasecmp(argv[i], "set",
MAX(command_len, 3))) {
continue;
} else if (!end
|| !strncasecmp(argv[i], "Names",
MAX(command_len, 1))
|| !strncasecmp(argv[i], "Resources",
MAX(command_len, 1))) {
if (name_list)
slurm_addto_char_list(name_list, argv[i]+end);
} else if (!strncasecmp(argv[i], "Clusters",
MAX(command_len, 1))) {
if (cluster_list) {
slurm_addto_char_list(cluster_list,
argv[i]+end);
if (sacctmgr_validate_cluster_list(
cluster_list) != SLURM_SUCCESS) {
exit_code=1;
fprintf(stderr,
" Need a valid cluster name to "
"add a cluster resource.\n");
}
} else {
exit_code=1;
fprintf(stderr,
" Can't modify the cluster "
"of an resource\n");
}
} else if (!strncasecmp(argv[i], "Count",
MAX(command_len, 3))) {
if (get_uint(argv[i]+end, &res->count,
"count") == SLURM_SUCCESS) {
set = 1;
}
} else if (!strncasecmp(argv[i], "Description",
MAX(command_len, 1))) {
if (!res->description)
res->description =
strip_quotes(argv[i]+end, NULL, 1);
set = 1;
} else if (!strncasecmp(argv[i], "Flags",
MAX(command_len, 2))) {
res->flags = str_2_res_flags(argv[i]+end, option);
if (res->flags == SLURMDB_RES_FLAG_NOTSET) {
char *tmp_char = slurmdb_res_flags_str(
SLURMDB_RES_FLAG_BASE);
printf(" Unknown Server Resource flag used "
"in:\n '%s'\n"
" Valid Server Resource flags are\n"
" '%s'\n", argv[i]+end, tmp_char);
xfree(tmp_char);
exit_code = 1;
} else
set = 1;
} else if (!strncasecmp(argv[i], "Manager",
MAX(command_len, 1))) {
if (!res->manager)
res->manager =
strip_quotes(argv[i]+end, NULL, 1);
set = 1;
} else if (!strncasecmp(argv[i], "PercentAllowed",
MAX(command_len, 1))) {
/* overload percent_used here */
if (get_uint16(argv[i]+end, &res->percent_used,
"PercentAllowed") == SLURM_SUCCESS) {
set = 1;
}
} else if (!strncasecmp(argv[i], "Server",
MAX(command_len, 1))) {
if (!res->server) {
res->server=
strip_quotes(argv[i]+end, NULL, 1);
}
set = 1;
} else if (!strncasecmp(argv[i], "Type",
MAX(command_len, 1))) {
char *temp = strip_quotes(argv[i]+end, NULL, 1);
if (!strncasecmp("License", temp,
MAX(strlen(temp), 1))) {
res->type = SLURMDB_RESOURCE_LICENSE;
} else {
exit_code=1;
fprintf(stderr,
" Unknown resource type: '%s' "
"Valid resources is License.\n",
temp);
}
} else {
exit_code = 1;
printf(" Unknown option: %s\n"
" Use keyword 'where' to modify condition\n",
argv[i]);
}
}
(*start) = i;
return set;
}
uint16 HCICommandCompletePDU::get_op_code () const
{
return get_uint16(3) ;
}
uint16_t gme_game_get_bonus_entry_score(const struct gme_game* g) {
assert(g->type==6);
return get_uint16(g->raw+2);
}
static int
decode_data(double **data, const xmlChar * input, dataFormat data_format,
codingTypes coding, byteOrder byte_order, int max_input_len)
{
GArray *data_stream, *debase64_buf, *decoded_data;
char *p, *end_ptr;
unsigned int i;
double val;
int data_count = 0;
gwy_debug("start.");
if (input == NULL) {
g_warning("SPML: decode_data(): NULL input");
*data = NULL;
return 0;
}
switch (coding) {
case ZLIB_COMPR_BASE64:
/*/ XXX: strlen() may not be nice there */
if (decode_b64((char *)input, &debase64_buf, strlen(input)) != 0) {
if (debase64_buf != NULL) {
g_array_free(debase64_buf, TRUE);
}
g_warning("Cannot decode data in BASE64 code.");
*data = NULL;
return 0;
}
if (inflate_dynamic_array(debase64_buf, &data_stream) != 0) {
g_warning("Cannot inflate compressed data.");
g_array_free(debase64_buf, TRUE);
if (data_stream != NULL) {
g_array_free(data_stream, TRUE);
}
*data = NULL;
return 0;
}
g_array_free(debase64_buf, TRUE);
break;
case BASE64:
/*/ XXX: strlen() may not be nice there */
if (decode_b64((char *)input, &data_stream, strlen(input)) != 0) {
g_warning("Cannot decode data in BASE64 code.");
if (data_stream != NULL) {
g_array_free(data_stream, TRUE);
}
*data = NULL;
return 0;
}
break;
case ASCII:
p = (char *)input;
data_stream = g_array_new(FALSE, FALSE, sizeof(double));
while (p != NULL) {
double num;
if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') {
p++;
continue;
}
num = g_ascii_strtod(p, &end_ptr);
if (num == 0 && end_ptr == p) {
g_warning("SPML: decode_data(): No conversion performed "
"from ASCII string.");
break;
}
g_array_append_val(data_stream, num);
p = end_ptr;
data_count++;
}
break;
/*/ TODO: */
case HEX:
case BINARY:
g_warning("SPML: decode_data(): Data coding 'HEX' and 'BINARY' "
"not supported.");
break;
case UNKNOWN_CODING:
break;
}
if (coding == ASCII) {
/* we have already decoded data */
if (max_input_len != -1 && data_count != max_input_len) {
/* not enough input data to fill array defined by length
* max_input_len */
g_warning("SPML: decode_data():\n"
"Input has not the same length as declared in "
"dimensions\n"
"(max:%d vs read:%d). Has the channel attribute\n"
"'channelReadMethodName'? The channel may be one\n"
"dimensional data used for axis values but not as\n"
"a source of data for Gwyddion.",
max_input_len, data_count);
g_array_free(data_stream, TRUE);
*data = NULL;
return 0;
}
else {
*data = (double *)data_stream->data;
/* we can free dynamic array, but not */
g_array_free(data_stream, FALSE);
/* containing data. */
gwy_debug("Datacount: %d", data_count);
return data_count;
}
}
decoded_data = g_array_new(FALSE, FALSE, sizeof(double));
p = data_stream->data;
i = 0;
switch (data_format) {
case FLOAT32:
while (i < data_stream->len) {
val = get_float32(&p, byte_order);
g_array_append_val(decoded_data, val);
data_count++;
i += sizeof(float);
}
break;
case FLOAT64:
while (i < data_stream->len) {
val = get_float64(&p, byte_order);
g_array_append_val(decoded_data, val);
i += sizeof(double);
}
break;
case INT8:
while (i < data_stream->len) {
val = get_int8(&p);
g_array_append_val(decoded_data, val);
i += sizeof(gint8);
}
break;
case INT16:
while (i < data_stream->len) {
val = get_int16(&p, byte_order);
g_array_append_val(decoded_data, val);
i += sizeof(gint16);
}
break;
case INT32:
while (i < data_stream->len) {
val = get_int32(&p, byte_order);
g_array_append_val(decoded_data, val);
i += sizeof(gint32);
}
break;
case UINT32:
while (i < data_stream->len) {
val = get_uint32(&p, byte_order);
g_array_append_val(decoded_data, val);
i += sizeof(guint32);
}
break;
case UINT8:
while (i < data_stream->len) {
val = get_uint8(&p);
g_array_append_val(decoded_data, val);
i += sizeof(guint8);
}
break;
case UINT16:
while (i < data_stream->len) {
val = get_uint16(&p, byte_order);
g_array_append_val(decoded_data, val);
i += sizeof(guint16);
}
break;
case STRING:
g_warning
("SPML: decode_data(): Data format 'String' not supported.");
break;
case UNKNOWN_DATAFORMAT:
g_warning("SPML: decode_data(): Unknown dataformat.");
break;
}
g_array_free(data_stream, TRUE);
data_count = decoded_data->len;
if (max_input_len != -1 && data_count != max_input_len) {
g_warning("SPML: decode_data():\n"
"Input has not the same length as declared in dimensions\n"
"(max:%d vs read:%d). Has the channel attribute\n"
"'channelReadMethodName'? The channel may be one\n"
"dimensional data used for axis values but not as\n"
"a source of data for Gwyddion.", max_input_len, data_count);
g_array_free(decoded_data, TRUE);
*data = NULL;
return 0;
}
*data = (double *)decoded_data->data;
g_array_free(decoded_data, FALSE); /* we can free dynamic array, but not */
/* containing data. */
gwy_debug("Datacount: %d", data_count);
return data_count;
}
uint16_t gme_game_get_repeat_oid(const struct gme_game* g) {
return get_uint16(gme_game_get_last_round_p(g)+2);
}
uint16 BNEP_LISTEN_REQ_T_PDU::get_ether_type() const
{
return get_uint16 ( BNEP_LISTEN_REQ_T_ether_type );
}
