static void io_acl_data(void *data)
{
struct vhci_conn *conn = data;
unsigned char buf[HCI_MAX_FRAME_SIZE], *ptr;
hci_acl_hdr *ah;
uint16_t flags;
int len;
ptr = buf + 1;
if (read_n(conn->fd, ptr, HCI_ACL_HDR_SIZE) <= 0) {
close_connection(conn);
return;
}
ah = (void *) ptr;
ptr += HCI_ACL_HDR_SIZE;
len = btohs(ah->dlen);
if (read_n(conn->fd, ptr, len) <= 0) {
close_connection(conn);
return;
}
buf[0] = HCI_ACLDATA_PKT;
flags = acl_flags(btohs(ah->handle));
ah->handle = htobs(acl_handle_pack(conn->handle, flags));
len += HCI_ACL_HDR_SIZE + 1;
write_snoop(vdev.dd, HCI_ACLDATA_PKT, 1, buf, len);
if (write(vdev.dev_fd, buf, len) < 0)
syslog(LOG_ERR, "ACL data write error");
}
int tcp_read(int fd, char *buf)
{
unsigned short len, flen;
register int rlen;
/* Read frame size */
if( (rlen = read_n(fd, (char *)&len, sizeof(short)) ) <= 0)
return rlen;
len = ntohs(len);
flen = len & VTUN_FSIZE_MASK;
if( flen > VTUN_FRAME_SIZE + VTUN_FRAME_OVERHEAD ){
/* Oversized frame, drop it. */
while( flen ){
len = min(flen, VTUN_FRAME_SIZE);
if( (rlen = read_n(fd, buf, len)) <= 0 )
break;
flen -= rlen;
}
return VTUN_BAD_FRAME;
}
if( len & ~VTUN_FSIZE_MASK ){
/* Return flags */
return len;
}
/* Read frame */
return read_n(fd, buf, flen);
}
// Read one cv::Mat from file
bool read_one(FILE * file, cv::Mat & data)
{
bool okay = true;
int32_t rows, cols; uint32_t type;
okay &= read_one(file, rows);
okay &= read_one(file, cols);
okay &= read_one(file, type);
if (rows <= 0 || cols <= 0 || (type & ~CV_MAT_TYPE_MASK) != 0)
return false;
data.create(rows, cols, type);
// If matrix memory is continuous, we can reshape the matrix
if (data.isContinuous()) {
cols = rows*cols;
rows = 1;
}
// Currently only supports float/double matrices!
if (data.depth() == CV_32F)
for (int r = 0; r < rows; ++r)
okay &= read_n(file, data.ptr<float>(r), cols);
else if (data.depth() == CV_64F)
for (int r = 0; r < rows; ++r)
okay &= read_n(file, data.ptr<double>(r), cols);
else
return false;
return okay;
}
ssize_t CwxSocket::read (CWX_HANDLE handle, CwxMsgHead& head, CwxMsgBlock*& msg, CwxTimeouter *timeout)
{
char szHead[CwxMsgHead::MSG_HEAD_LEN];
ssize_t ret = read_n(handle, szHead, CwxMsgHead::MSG_HEAD_LEN, timeout, NULL);
if (ret != CwxMsgHead::MSG_HEAD_LEN)
return ret;
if (!head.fromNet(szHead))
{
errno = EBADMSG;
return -1;
}
msg = CwxMsgBlockAlloc::malloc(head.getDataLen());
if (!msg)
{
errno = ENOMEM;
return -1;
}
ret = read_n(handle, msg->wr_ptr(), head.getDataLen(), timeout, NULL);
if (ret != (ssize_t)head.getDataLen())
{
CwxMsgBlockAlloc::free(msg);
msg = NULL;
return ret;
}
msg->wr_ptr(head.getDataLen());
return CwxMsgHead::MSG_HEAD_LEN + head.getDataLen();
}
int pe_load_res_file(TCCState *s1, int fd) {
struct pe_rsrc_header hdr;
Section *rsrc_section;
int i, ret = -1;
BYTE *ptr;
lseek(fd, 0, SEEK_SET);
if (!read_n(fd, &hdr, sizeof hdr)) goto quit;
if (!pe_test_res_file(&hdr, sizeof hdr)) goto quit;
rsrc_section = new_section(s1, ".rsrc", SHT_PROGBITS, SHF_ALLOC);
ptr = section_ptr_add(rsrc_section, hdr.sectionhdr.SizeOfRawData);
lseek(fd, hdr.sectionhdr.PointerToRawData, SEEK_SET);
if (!read_n(fd, ptr, hdr.sectionhdr.SizeOfRawData)) goto quit;
lseek(fd, hdr.sectionhdr.PointerToRelocations, SEEK_SET);
for (i = 0; i < hdr.sectionhdr.NumberOfRelocations; ++i) {
struct pe_rsrc_reloc rel;
if (!read_n(fd, &rel, sizeof rel)) goto quit;
if (rel.type != 7) goto quit; // DIR32NB
put_elf_reloc(symtab_section, rsrc_section, rel.offset, R_386_RELATIVE, 0);
}
ret = 0;
quit:
if (ret) error_noabort("unrecognized resource file format");
return ret;
}
int read_env (int fd, char ***envp)
{
int envc = 0;
int i;
if (read_n (fd, &envc, sizeof (int)) < 0) {
fprintf (stderr, "systemsafe: read_env: %s\n", strerror (errno));
return (-1);
}
if (!(*envp = malloc ((envc + 1) * sizeof (**envp)))) {
fprintf (stderr, "systemsafe: read_env: malloc: %s\n", strerror (errno));
return (-1);
}
for (i = 0; i < envc; i++) {
char *entry;
if (read_string (fd, &entry) < 0) {
fprintf (stderr, "systemsafe: %s\n", strerror (errno));
free_env (*envp);
return (-1);
}
if (strncmp ("LD_PRELOAD=", entry, 10) == 0)
entry [11] = '\0';
(*envp)[i] = entry;
}
(*envp)[envc] = NULL;
return (0);
}
string client::recv_bulk_reply_()
{
int_type length = recv_bulk_reply_(prefix_single_bulk_reply);
if (length == -1)
return client::missing_value;
int_type real_length = length + 2; // CRLF
string data = read_n(socket_, real_length);
#ifndef NDEBUG
output_proto_debug(data.substr(0, data.length()-2));
#endif
if (data.empty())
{
cout<<"invalid bulk reply data; empty"<<endl;
//throw protocol_error("invalid bulk reply data; empty");
}
if (data.length() != static_cast<string::size_type>(real_length))
// throw protocol_error("invalid bulk reply data; data of unexpected length");
{
cout<<"invalid bulk reply data; data of unexpected length"<<endl;
}
data.erase(data.size() - 2);
return data;
}
bool RoboClaw::ReadM2MaxCurrent(uint8_t address,uint32_t &max){
uint32_t tmax,dummy;
bool valid = read_n(2,address,GETM2MAXCURRENT,&tmax,&dummy);
if(valid)
max = tmax;
return valid;
}
static int write_block(unsigned char tr, unsigned char se, const unsigned char *blk, int size, int read_status)
{
int i = 0;
unsigned char status[2];
SETSTATEDEBUG((void)0);
status[0] = tr; status[1] = se;
write_n(status, 2);
SETSTATEDEBUG((void)0);
/* send first byte twice if length is odd */
if(size % 2) {
write_n(blk, 2);
i = 1;
}
SETSTATEDEBUG(debugLibImgByteCount=0);
write_n(blk+i, size-i);
SETSTATEDEBUG(debugLibImgByteCount=-1);
#ifndef USE_CBM_IEC_WAIT
if(size == BLOCKSIZE) {
arch_usleep(20000);
}
#endif
SETSTATEDEBUG((void)0);
read_n(status, 2);
SETSTATEDEBUG((void)0);
return status[1];
}
static gboolean io_acl_data(GIOChannel *chan, GIOCondition cond, gpointer data)
{
struct vhci_conn *conn = (struct vhci_conn *) data;
unsigned char buf[HCI_MAX_FRAME_SIZE], *ptr;
hci_acl_hdr *ah;
uint16_t flags;
int fd, err, len;
if (cond & G_IO_NVAL) {
g_io_channel_unref(chan);
return FALSE;
}
if (cond & G_IO_HUP) {
close_connection(conn);
return FALSE;
}
fd = g_io_channel_unix_get_fd(chan);
ptr = buf + 1;
if (read_n(fd, ptr, HCI_ACL_HDR_SIZE) <= 0) {
close_connection(conn);
return FALSE;
}
ah = (void *) ptr;
ptr += HCI_ACL_HDR_SIZE;
len = btohs(ah->dlen);
if (read_n(fd, ptr, len) <= 0) {
close_connection(conn);
return FALSE;
}
buf[0] = HCI_ACLDATA_PKT;
flags = acl_flags(btohs(ah->handle));
ah->handle = htobs(acl_handle_pack(conn->handle, flags));
len += HCI_ACL_HDR_SIZE + 1;
write_snoop(vdev.dd, HCI_ACLDATA_PKT, 1, buf, len);
err = write(vdev.fd, buf, len);
return TRUE;
}
bool RoboClaw::ReadM2PositionPID(uint8_t address,float &Kp_fp,float &Ki_fp,float &Kd_fp,uint32_t &KiMax,uint32_t &DeadZone,uint32_t &Min,uint32_t &Max){
uint32_t Kp,Ki,Kd;
bool valid = read_n(7,address,READM2POSPID,&Kp,&Ki,&Kd,&KiMax,&DeadZone,&Min,&Max);
Kp_fp = ((float)Kp)/1024;
Ki_fp = ((float)Ki)/1024;
Kd_fp = ((float)Kd)/1024;
return valid;
}
bool RoboClaw::ReadM2VelocityPID(uint8_t address,float &Kp_fp,float &Ki_fp,float &Kd_fp,uint32_t &qpps){
uint32_t Kp,Ki,Kd;
bool valid = read_n(4,address,READM2PID,&Kp,&Ki,&Kd,&qpps);
Kp_fp = ((float)Kp)/65536;
Ki_fp = ((float)Ki)/65536;
Kd_fp = ((float)Kd)/65536;
return valid;
}
void store(uint32_t address, uint32_t length){
for (uint32_t i = 0; i*4 < length; i++) {
int8_t buffer[9];
int8_t* ascii_instruction = read_n(buffer,8);
volatile uint32_t* p = (volatile uint32_t*)(address+i*4);
*p = ascii_hex_to_uint32(ascii_instruction);
}
}
void* read_from_sock(void* none){
struct pktdata_t recvpktdata;
unsigned int size;
while(1){
read_n(tcpudp_fd,(char*)&recvpktdata.len,4);
size=ntohl(recvpktdata.len);
if(size>MAX_PKT){
printf("size received is %d,greater then MAX_PKT\n",size);
pthread_cancel(pt_read_from_if);
pthread_exit(none);
}
printf("read %d bytes from tcp sock\n",size);
read_n(tcpudp_fd,recvpktdata.data,size);
write_n(tun_fd,recvpktdata.data,size);
}
return none;
}
void *recv_thread_entry(void *arg)
{
int bytes;
stream_head_t sh;
codec_head_t ch;
circular_queue *cq = NULL;
while (network_on)
{
LOGD("begin read");
bytes = read_n(sockfd, &sh, sizeof (sh));
LOGD("read stream head");
if (bytes != sizeof (sh))
break;
bytes = read_n(sockfd, &ch, sizeof (ch));
// LOGD("read codec head");
if (bytes != sizeof (ch))
break;
bytes = read_n(sockfd, recv_buffer, ch.frame_size);
// LOGD("read data");
if (bytes != ch.frame_size)
break;
if (sh.msg_type == AUDIO_TYPE)
cq = audio_cq;
else
cq = video_cq;
cq_write(cq, recv_buffer, ch.frame_size - 4);
// if (cq == video_cq)
// {
// LOGD("video frame %lu after recieving: %lu", ch.serial_num, clock());
// }
// else
// {
// LOGD("audio frame %lu after recieving: %lu", ch.serial_num, clock());
// }
}
return NULL;
}
static int read_gcr_block(unsigned char *se, unsigned char *gcrbuf)
{
unsigned char s[2];
SETSTATEDEBUG((void)0);
read_n(s, 2);
*se = s[1];
SETSTATEDEBUG((void)0);
read_n(s, 2);
if(s[1]) {
return s[1];
}
SETSTATEDEBUG(debugLibImgByteCount=0);
read_n(gcrbuf, GCRBUFSIZE);
SETSTATEDEBUG(debugLibImgByteCount=-1);
SETSTATEDEBUG((void)0);
return 0;
}
static int read_block(unsigned char tr, unsigned char se, unsigned char *block)
{
unsigned char status[2];
SETSTATEDEBUG((void)0);
status[0] = tr; status[1] = se;
write_n(status, 2);
#ifndef USE_CBM_IEC_WAIT
arch_usleep(20000);
#endif
SETSTATEDEBUG((void)0);
read_n(status, 2);
SETSTATEDEBUG(debugLibImgByteCount=0);
read_n(block, BLOCKSIZE);
SETSTATEDEBUG(debugLibImgByteCount=-1);
SETSTATEDEBUG((void)0);
return status[1];
}
/* Read N bytes with timeout */
int readn_t(int fd, void *buf, size_t count, time_t timeout)
{
fd_set fdset;
struct timeval tv;
tv.tv_usec=0; tv.tv_sec=timeout;
FD_ZERO(&fdset);
FD_SET(fd,&fdset);
if( select(fd+1,&fdset,NULL,NULL,&tv) <= 0)
return -1;
return read_n(fd, buf, count);
}
static int read_string (int fd, char **bufp)
{
int len = 0;
int rc;
*bufp = NULL;
/*
* Read string length
*/
if ((rc = read_n (fd, &len, sizeof (int))) < 0) {
fprintf (stderr, "systemsafe: read_string: %s\n", strerror (errno));
return (-1);
}
if (rc == 0)
return (0);
if ((*bufp = malloc (len + 1)) == NULL) {
fprintf (stderr, "systemsafe: read_string: malloc (%d): %s\n",
len, strerror (errno));
return (-1);
}
if ((rc = read_n (fd, *bufp, len)) < 0) {
fprintf (stderr, "systemsafe: read_string: %s\n", strerror (errno));
return (-1);
}
if (rc == 0)
return (0);
(*bufp) [len] = '\0';
return (len);
}
inline void read(FILE* fp) {
// assumes the stream is already positioned to the beginning
{
uint8_t* buf1 = new uint8_t[eHeaderSize];
size_t numRead = read_n(buf1, fp, eHeaderSize);
if (numRead != eHeaderSize)
{
std::ostringstream oss;
oss << " read size was invalid, not " << eHeaderSize << std::endl;
}
uint8_t* p1 = buf1;
reserved = read_field<uint16_t>(p1);
uint8_t userId_data[eUserIdSize];
read_array_field(p1, userId_data, eUserIdSize);
userId = std::string((const char*)&userId_data);
recordId = read_field<uint16_t>(p1);
size = read_field<uint16_t>(p1);
uint8_t description_data[eDescriptionSize];
read_array_field(p1, description_data, eDescriptionSize);
description = std::string( (const char*)&description_data);
delete[] buf1;
}
data = new uint8_t[size];
{
read_n(data, fp, size);
}
return;
}
static gboolean io_conn_ind(GIOChannel *chan, GIOCondition cond, gpointer data)
{
struct vhci_link_info info;
struct vhci_conn *conn;
struct sockaddr_in sa;
socklen_t len;
int sk, nsk, h;
if (cond & G_IO_NVAL)
return FALSE;
sk = g_io_channel_unix_get_fd(chan);
len = sizeof(sa);
if ((nsk = accept(sk, (struct sockaddr *) &sa, &len)) < 0)
return TRUE;
if (read_n(nsk, &info, sizeof(info)) < 0) {
syslog(LOG_ERR, "Can't read link info");
return TRUE;
}
if (!(conn = malloc(sizeof(*conn)))) {
syslog(LOG_ERR, "Can't alloc new connection");
close(nsk);
return TRUE;
}
bacpy(&conn->dest, &info.bdaddr);
for (h = 0; h < VHCI_MAX_CONN; h++)
if (!vconn[h])
goto accepted;
syslog(LOG_ERR, "Too many connections");
free(conn);
close(nsk);
return TRUE;
accepted:
vconn[h] = conn;
conn->handle = h + 1;
conn->chan = g_io_channel_unix_new(nsk);
connect_request(conn);
return TRUE;
}
void getack(){
unsigned char integ[6];
if(read_n(tcpudp_fd,(char*)integ,6)==-1){
perror("read");
exit(-1);
}
if(!(integ[0]==65 &&
integ[1]==66 &&
integ[2]==67 &&
integ[3]==68 &&
integ[4]==69 &&
integ[5]==70)){
printf("ack failed\n");
exit(-1);
}else{
printf("got ack\n");
}
}
/* This function is not reentrable */
static struct link_key *__get_link_key(int f, bdaddr_t *sba, bdaddr_t *dba)
{
static struct link_key k;
struct link_key *key = NULL;
int r;
while ((r = read_n(f, &k, sizeof(k)))) {
if (r < 0) {
syslog(LOG_ERR, "Link key database read failed: %s (%d)",
strerror(errno), errno);
break;
}
if (!bacmp(&k.sba, sba) && !bacmp(&k.dba, dba)) {
key = &k;
break;
}
}
return key;
}
static void io_conn_ind(void)
{
struct vhci_link_info info;
struct vhci_conn *conn;
struct sockaddr_in sa;
socklen_t len;
int nsk, h;
len = sizeof(sa);
if ((nsk = accept(vdev.scan_fd, (struct sockaddr *) &sa, &len)) < 0)
return;
if (read_n(nsk, &info, sizeof(info)) < 0) {
syslog(LOG_ERR, "Can't read link info");
return;
}
if (!(conn = malloc(sizeof(*conn)))) {
syslog(LOG_ERR, "Can't alloc new connection");
close(nsk);
return;
}
bacpy(&conn->dest, &info.bdaddr);
for (h = 0; h < VHCI_MAX_CONN; h++)
if (!vconn[h])
goto accepted;
syslog(LOG_ERR, "Too many connections");
free(conn);
close(nsk);
return;
accepted:
vconn[h] = conn;
conn->handle = h + 1;
conn->fd = nsk;
connect_request(conn);
}
int main(int argc, char ** argv) {
(void)argc;
long n = atol(argv[1]);
int low,high;
long i;
double t;
if (!pow2check(n)) {
fprintf(stderr, "error : n (%ld) not a power of two\n", n);
exit(1);
}
sample_t * buf = calloc(sizeof(sample_t), n);
complex double * X = calloc(sizeof(complex double), n);
complex double * Y = calloc(sizeof(complex double), n);
low = atoi(argv[2]);
high = atoi(argv[3]);
while (1) {
/* 標準入力からn個標本を読む */
ssize_t m = read_n(0, n * sizeof(sample_t), buf);
if (m == 0) break;
/* 複素数の配列に変換 */
sample_to_complex(buf, X, n);
/* FFT -> Y */
fft(X, Y, n);
// Yのバンド外を0にする
// t = (double) n / SAMPLING_FREQEUENCY;
// for (i = 0; i < n; ++i){
// if(i/t<low || i/t>high){
// Y[i] = 0;
// }
// }
/* IFFT -> Z */
ifft(Y, X, n);
/* 標本の配列に変換 */
complex_to_sample(Y, buf, n);
/* 標準出力へ出力 */
write_n(1, m, buf);
}
return 0;
}
/* SSL 2.0 imlementation for SSL_read/SSL_peek -
* This routine will return 0 to len bytes, decrypted etc if required.
*/
static int ssl2_read_internal(SSL *s, void *buf, int len, int peek)
{
int n;
unsigned char mac[MAX_MAC_SIZE];
unsigned char *p;
int i;
int mac_size;
ssl2_read_again:
if (SSL_in_init(s) && !s->in_handshake)
{
n=s->handshake_func(s);
if (n < 0) return(n);
if (n == 0)
{
SSLerr(SSL_F_SSL2_READ_INTERNAL,SSL_R_SSL_HANDSHAKE_FAILURE);
return(-1);
}
}
clear_sys_error();
s->rwstate=SSL_NOTHING;
if (len <= 0) return(len);
if (s->s2->ract_data_length != 0) /* read from buffer */
{
if (len > s->s2->ract_data_length)
n=s->s2->ract_data_length;
else
n=len;
memcpy(buf,s->s2->ract_data,(unsigned int)n);
if (!peek)
{
s->s2->ract_data_length-=n;
s->s2->ract_data+=n;
if (s->s2->ract_data_length == 0)
s->rstate=SSL_ST_READ_HEADER;
}
return(n);
}
/* s->s2->ract_data_length == 0
*
* Fill the buffer, then goto ssl2_read_again.
*/
if (s->rstate == SSL_ST_READ_HEADER)
{
if (s->first_packet)
{
n=read_n(s,5,SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER+2,0);
if (n <= 0) return(n); /* error or non-blocking */
s->first_packet=0;
p=s->packet;
if (!((p[0] & 0x80) && (
(p[2] == SSL2_MT_CLIENT_HELLO) ||
(p[2] == SSL2_MT_SERVER_HELLO))))
{
SSLerr(SSL_F_SSL2_READ_INTERNAL,SSL_R_NON_SSLV2_INITIAL_PACKET);
return(-1);
}
}
else
{
n=read_n(s,2,SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER+2,0);
if (n <= 0) return(n); /* error or non-blocking */
}
/* part read stuff */
s->rstate=SSL_ST_READ_BODY;
p=s->packet;
/* Do header */
/*s->s2->padding=0;*/
s->s2->escape=0;
s->s2->rlength=(((unsigned int)p[0])<<8)|((unsigned int)p[1]);
if ((p[0] & TWO_BYTE_BIT)) /* Two byte header? */
{
s->s2->three_byte_header=0;
s->s2->rlength&=TWO_BYTE_MASK;
}
else
{
s->s2->three_byte_header=1;
s->s2->rlength&=THREE_BYTE_MASK;
/* security >s2->escape */
s->s2->escape=((p[0] & SEC_ESC_BIT))?1:0;
}
}
if (s->rstate == SSL_ST_READ_BODY)
{
n=s->s2->rlength+2+s->s2->three_byte_header;
if (n > (int)s->packet_length)
{
n-=s->packet_length;
i=read_n(s,(unsigned int)n,(unsigned int)n,1);
if (i <= 0) return(i); /* ERROR */
}
p= &(s->packet[2]);
s->rstate=SSL_ST_READ_HEADER;
if (s->s2->three_byte_header)
s->s2->padding= *(p++);
else s->s2->padding=0;
/* Data portion */
if (s->s2->clear_text)
{
mac_size = 0;
s->s2->mac_data=p;
s->s2->ract_data=p;
if (s->s2->padding)
{
SSLerr(SSL_F_SSL2_READ_INTERNAL,SSL_R_ILLEGAL_PADDING);
return(-1);
}
}
else
{
mac_size=EVP_MD_CTX_size(s->read_hash);
if (mac_size < 0)
return -1;
OPENSSL_assert(mac_size <= MAX_MAC_SIZE);
s->s2->mac_data=p;
s->s2->ract_data= &p[mac_size];
if (s->s2->padding + mac_size > s->s2->rlength)
{
SSLerr(SSL_F_SSL2_READ_INTERNAL,SSL_R_ILLEGAL_PADDING);
return(-1);
}
}
s->s2->ract_data_length=s->s2->rlength;
/* added a check for length > max_size in case
* encryption was not turned on yet due to an error */
if ((!s->s2->clear_text) &&
(s->s2->rlength >= (unsigned int)mac_size))
{
ssl2_enc(s,0);
s->s2->ract_data_length-=mac_size;
ssl2_mac(s,mac,0);
s->s2->ract_data_length-=s->s2->padding;
if ( (CRYPTO_memcmp(mac,s->s2->mac_data,mac_size) != 0) ||
(s->s2->rlength%EVP_CIPHER_CTX_block_size(s->enc_read_ctx) != 0))
{
SSLerr(SSL_F_SSL2_READ_INTERNAL,SSL_R_BAD_MAC_DECODE);
return(-1);
}
}
INC32(s->s2->read_sequence); /* expect next number */
/* s->s2->ract_data is now available for processing */
/* Possibly the packet that we just read had 0 actual data bytes.
* (SSLeay/OpenSSL itself never sends such packets; see ssl2_write.)
* In this case, returning 0 would be interpreted by the caller
* as indicating EOF, so it's not a good idea. Instead, we just
* continue reading; thus ssl2_read_internal may have to process
* multiple packets before it can return.
*
* [Note that using select() for blocking sockets *never* guarantees
* that the next SSL_read will not block -- the available
* data may contain incomplete packets, and except for SSL 2,
* renegotiation can confuse things even more.] */
goto ssl2_read_again; /* This should really be
* "return ssl2_read(s,buf,len)",
* but that would allow for
* denial-of-service attacks if a
* C compiler is used that does not
* recognize end-recursion. */
}
else
{
SSLerr(SSL_F_SSL2_READ_INTERNAL,SSL_R_BAD_STATE);
return(-1);
}
}
gint main (gint argc, gchar **argv)
{
struct _CamelLockHelperMsg msg;
gint len;
gint res;
gchar *path;
fd_set rset;
struct timeval tv;
struct _lock_info *info;
setup_process ();
do {
/* do a poll/etc, so we can refresh the .locks as required ... */
FD_ZERO (&rset);
FD_SET (STDIN_FILENO, &rset);
/* check the minimum timeout we need to refresh the next oldest lock */
if (lock_info_list) {
time_t now = time (NULL);
time_t left;
time_t delay = CAMEL_DOT_LOCK_REFRESH;
info = lock_info_list;
while (info) {
left = CAMEL_DOT_LOCK_REFRESH - (now - info->stamp);
left = MAX (left, 0);
delay = MIN (left, delay);
info = info->next;
}
tv.tv_sec = delay;
tv.tv_usec = 0;
}
d (fprintf (stderr, "lock helper waiting for input\n"));
if (select (STDIN_FILENO + 1, &rset, NULL, NULL, lock_info_list ? &tv : NULL) == -1) {
if (errno == EINTR)
break;
continue;
}
/* did we get a timeout? scan for any locks that need updating */
if (!FD_ISSET (STDIN_FILENO, &rset)) {
time_t now = time (NULL);
time_t left;
d (fprintf (stderr, "Got a timeout, checking locks\n"));
info = lock_info_list;
while (info) {
left = (now - info->stamp);
if (left >= CAMEL_DOT_LOCK_REFRESH) {
lock_touch (info->path);
info->stamp = now;
}
info = info->next;
}
continue;
}
len = read_n (STDIN_FILENO, &msg, sizeof (msg));
if (len == 0)
break;
res = CAMEL_LOCK_HELPER_STATUS_PROTOCOL;
if (len == sizeof (msg) && msg.magic == CAMEL_LOCK_HELPER_MAGIC) {
switch (msg.id) {
case CAMEL_LOCK_HELPER_LOCK:
res = CAMEL_LOCK_HELPER_STATUS_NOMEM;
if (msg.data > 0xffff) {
res = CAMEL_LOCK_HELPER_STATUS_PROTOCOL;
} else if ((path = malloc (msg.data + 1)) != NULL) {
res = CAMEL_LOCK_HELPER_STATUS_PROTOCOL;
len = read_n (STDIN_FILENO, path, msg.data);
if (len == msg.data) {
path[len] = 0;
res = lock_path (path, &msg.data);
}
free (path);
}
break;
case CAMEL_LOCK_HELPER_UNLOCK:
res = unlock_id (msg.data);
break;
}
}
d (fprintf (stderr, "returning result %d\n", res));
msg.id = res;
msg.magic = CAMEL_LOCK_HELPER_RETURN_MAGIC;
write_n (STDOUT_FILENO, &msg, sizeof (msg));
} while (1);
d (fprintf (stderr, "parent exited, clsoing down remaining id's\n"));
while (lock_info_list)
unlock_id (lock_info_list->id);
return 0;
}
static void read_dump(int fd)
{
struct hcidump_hdr dh;
struct btsnoop_pkt dp;
struct pktlog_hdr ph;
struct frame frm;
int err;
frm.data = malloc(HCI_MAX_FRAME_SIZE);
if (!frm.data) {
perror("Can't allocate data buffer");
exit(1);
}
while (1) {
if (parser.flags & DUMP_PKTLOG)
err = read_n(fd, (void *) &ph, PKTLOG_HDR_SIZE);
else if (parser.flags & DUMP_BTSNOOP)
err = read_n(fd, (void *) &dp, BTSNOOP_PKT_SIZE);
else
err = read_n(fd, (void *) &dh, HCIDUMP_HDR_SIZE);
if (err < 0)
goto failed;
if (!err)
goto done;
if (parser.flags & DUMP_PKTLOG) {
switch (ph.type) {
case 0x00:
((uint8_t *) frm.data)[0] = HCI_COMMAND_PKT;
frm.in = 0;
break;
case 0x01:
((uint8_t *) frm.data)[0] = HCI_EVENT_PKT;
frm.in = 1;
break;
case 0x02:
((uint8_t *) frm.data)[0] = HCI_ACLDATA_PKT;
frm.in = 0;
break;
case 0x03:
((uint8_t *) frm.data)[0] = HCI_ACLDATA_PKT;
frm.in = 1;
break;
default:
lseek(fd, be32toh(ph.len) - 9, SEEK_CUR);
continue;
}
frm.data_len = be32toh(ph.len) - 8;
err = read_n(fd, frm.data + 1, frm.data_len - 1);
} else if (parser.flags & DUMP_BTSNOOP) {
uint32_t opcode;
uint8_t pkt_type;
switch (btsnoop_type) {
case 1001:
if (be32toh(dp.flags) & 0x02) {
if (be32toh(dp.flags) & 0x01)
pkt_type = HCI_EVENT_PKT;
else
pkt_type = HCI_COMMAND_PKT;
} else
pkt_type = HCI_ACLDATA_PKT;
((uint8_t *) frm.data)[0] = pkt_type;
frm.data_len = be32toh(dp.len) + 1;
err = read_n(fd, frm.data + 1, frm.data_len - 1);
break;
case 1002:
frm.data_len = be32toh(dp.len);
err = read_n(fd, frm.data, frm.data_len);
break;
case 2001:
opcode = be32toh(dp.flags) & 0xffff;
switch (opcode) {
case 2:
pkt_type = HCI_COMMAND_PKT;
frm.in = 0;
break;
case 3:
pkt_type = HCI_EVENT_PKT;
frm.in = 1;
break;
case 4:
pkt_type = HCI_ACLDATA_PKT;
frm.in = 0;
break;
case 5:
pkt_type = HCI_ACLDATA_PKT;
frm.in = 1;
break;
case 6:
pkt_type = HCI_SCODATA_PKT;
frm.in = 0;
break;
case 7:
pkt_type = HCI_SCODATA_PKT;
frm.in = 1;
break;
default:
pkt_type = 0xff;
break;
}
((uint8_t *) frm.data)[0] = pkt_type;
frm.data_len = be32toh(dp.len) + 1;
err = read_n(fd, frm.data + 1, frm.data_len - 1);
}
} else {
frm.data_len = btohs(dh.len);
err = read_n(fd, frm.data, frm.data_len);
}
if (err < 0)
goto failed;
if (!err)
goto done;
frm.ptr = frm.data;
frm.len = frm.data_len;
if (parser.flags & DUMP_PKTLOG) {
uint64_t ts;
ts = be64toh(ph.ts);
frm.ts.tv_sec = ts >> 32;
frm.ts.tv_usec = ts & 0xffffffff;
} else if (parser.flags & DUMP_BTSNOOP) {
static int ldap_deactivate_utmp(char *devnam)
{
int rc;
int fd;
off_t offset;
struct ppp_utmp entry;
char *device;
char *p;
if ((device = malloc(MAXPATHLEN)) == NULL) {
error("Not enough memory\n");
return -1;
}
memset(device, 0, MAXPATHLEN);
memset(&entry, 0, sizeof(struct ppp_utmp));
p = device;
strncpy(device, devnam, MAXLINELEN-1);
if(strncmp(device,"/dev/",5) == 0) p += 5;
#ifdef DEBUG
info("LDAP: deactivating %s\n",devnam);
#endif
if ((fd = open(UTMP, O_RDWR, 0600)) == -1){
error("LDAP: can't open utmp file: %s\n",
strerror(errno));
return -1;
}
if ((rc = lockf(fd, F_LOCK, 0)) == -1){
error("LDAP: can't lock utmp file: %s\n",
strerror(errno));
return -1;
}
while(read_n(fd, &entry, sizeof(struct ppp_utmp))) {
if (strncmp(entry.line, p, MAXLINELEN-1) == 0) {
entry.state = IDLE;
lseek(fd, -sizeof(struct ppp_utmp), SEEK_CUR);
if ((rc = write_n(fd, &entry, sizeof(struct ppp_utmp))) == -1) {
error("LDAP: can't change utmp record status: %s\n",
strerror(errno));
return -1;
}
}
}
free(device);
lseek(fd, 0, SEEK_SET);
if ((rc = lockf(fd, F_ULOCK, 0)) == -1){
error("LDAP: can't unlock utmp file: %s\n",
strerror(errno));
return -1;
}
close(fd);
return 1;
}
static int ldap_activate_utmp(struct ldap_data *ldap_data,
char *devnam, char *ppp_devname, char* user)
{
int rc;
int fd;
off_t offset;
struct ppp_utmp entry;
char *device;
char *p;
memset(&entry, 0, sizeof(struct ppp_utmp));
if ((device = malloc(MAXPATHLEN)) == NULL) {
error("Not enough memory\n");
return -1;
}
memset(device, '\0', MAXPATHLEN);
if ((fd = open(UTMP , O_RDWR | O_CREAT, 0644)) == -1)
{
error("LDAP: can't open utmp file\n");
return -1;
}
strncpy(device, devnam, MAXLINELEN-1);
p = device;
if(strncmp(device,"/dev/",5) == 0) p += 5;
if ((rc = lockf(fd, F_LOCK, 0)) == -1)
{
error("LDAP: can't lock utmp file: %s\n",
strerror(errno));
return -1;
}
switch ((offset = utmp_seek(fd, devnam))) {
case -1:
strncpy(entry.line, p, MAXLINELEN-1);
strncpy(entry.login, user, MAXNAMELEN-1);
strncpy(entry.ifname, ppp_devname, MAXIFLEN-1);
if (!ldap_data->address_set)
entry.ip_address = ipcp_wantoptions[0].hisaddr;
else entry.ip_address = ldap_data->addr;
entry.time = time(NULL);
entry.state = ACTIVE;
lseek(fd, 0, SEEK_END);
if ((write_n(fd, &entry, sizeof(struct ppp_utmp))) == -1){
error("LDAP: failed to write utmp entry\n");
return -1;
}
break;
default:
lseek(fd, offset, SEEK_SET);
read_n(fd,&entry,sizeof(struct ppp_utmp));
strncpy(entry.line, p, MAXLINELEN-1);
strncpy(entry.login, user, MAXNAMELEN-1);
strncpy(entry.ifname, ppp_devname, MAXIFLEN-1);
if (!ldap_data->address_set)
entry.ip_address = ipcp_wantoptions[0].hisaddr;
else entry.ip_address = ldap_data->addr;
entry.time = time(NULL);
entry.state = ACTIVE;
lseek(fd, offset, SEEK_SET);
if ((write_n(fd, &entry, sizeof(struct ppp_utmp))) == -1){
error("LDAP: failed to write utmp entry\n");
return -1;
}
break;
}
free(device);
lseek(fd, 0, SEEK_SET);
if ((rc = lockf(fd, F_ULOCK, 0)) == -1)
{
error("LDAP: can't unlock utmp file: %s\n",
strerror(errno));
return -1;
}
if ((rc = close(fd)) == -1)
{
error("LDAP: can't close utmp file: %s\n",
strerror(errno));
return -1;
}
return 1;
}
