Exemple #1
0
/* to tail */
void zlst_push(void *PHEAD, void *ZNODE)
{
        struct znode *head;
        struct znode *znode;

        if(!ZNODE) {
                RPT(RPT_ERR, "push: bad node");
                return;
        }
        znode = (struct znode *)ZNODE;

        if(!PHEAD) {
                RPT(RPT_ERR, "push: NOT a list");
                return;
        }
        head = *(struct znode **)PHEAD;

        if(!head) {
                RPT(RPT_INF, "push: into empty list");
                znode->tail = znode;
                znode->next = NULL;
                znode->prev = NULL;
                *(struct znode **)PHEAD = znode;
                return;
        }

        RPT(RPT_INF, "push: ok");
        znode->next = NULL;
        znode->prev = head->tail;
        head->tail->next = znode; /* head->tail is ok! */
        head->tail = znode;
        return;
}
Exemple #2
0
/* it's up to the caller to free the node! */
void *zlst_pop(void *PHEAD)
{
        struct znode *head;
        struct znode *tail;

        if(!PHEAD) {
                RPT(RPT_ERR, "pop: NOT a list");
                return NULL;
        }
        head = *(struct znode **)PHEAD;

        if(!head) {
                RPT(RPT_INF, "pop: from empty list");
                return NULL;
        }
        tail = head->tail;

        if(!(head->next)) {
                RPT(RPT_INF, "pop: from one node list");
                *(struct znode **)PHEAD = NULL;
                return head;
        }

        if(!(tail->prev)) {
                RPT(RPT_ERR, "pop: bad list");
                return NULL;
        }

        RPT(RPT_INF, "pop: ok");
        tail->prev->next = NULL;
        head->tail = tail->prev;
        return tail;
}
Exemple #3
0
/* it's up to the caller to free the node! */
void *zlst_shift(void *PHEAD)
{
        struct znode *head;

        if(!PHEAD) {
                RPT(RPT_ERR, "shift: NOT a list");
                return NULL;
        }
        head = *(struct znode **)PHEAD;

        if(!head) {
                RPT(RPT_INF, "shift: from empty list");
                return NULL;
        }

        if(!(head->next)) {
                RPT(RPT_INF, "shift: from one node list");
                *(struct znode **)PHEAD = NULL;
                return head;
        }

        RPT(RPT_INF, "shift: ok");
        head->next->prev = NULL;
        head->next->tail = head->tail;
        *(struct znode **)PHEAD = head->next;
        return head;
}
Exemple #4
0
/* to head */
void zlst_unshift(void *PHEAD, void *ZNODE)
{
        struct znode *head;
        struct znode *znode;

        if(!ZNODE) {
                RPT(RPT_ERR, "unshift: bad node");
                return;
        }
        znode = (struct znode *)ZNODE;

        if(!PHEAD) {
                RPT(RPT_ERR, "unshift: NOT a list");
                return;
        }
        head = *(struct znode **)PHEAD;

        if(!head) {
                RPT(RPT_INF, "unshift: into empty list");
                znode->tail = znode;
                znode->next = NULL;
                znode->prev = NULL;
                *(struct znode **)PHEAD = znode;
                return;
        }

        RPT(RPT_INF, "unshift: ok");
        znode->tail = head->tail;
        znode->next = head;
        znode->prev = NULL;
        head->prev = znode;
        *(struct znode **)PHEAD = znode;
        return;
}
Exemple #5
0
void *zlst_search(void *PHEAD, int key)
{
        struct znode *head;
        struct znode *znode;

        if(!PHEAD) {
                RPT(RPT_ERR, "search: NOT a list");
                return NULL;
        }
        head = *(struct znode **)PHEAD;

        if(!head) {
                RPT(RPT_INF, "search: in an empty list");
                return NULL;
        }

        for(znode = head; znode; znode = znode->next) {
                if(znode->key == key) {
                        RPT(RPT_INF, "search: got %d", key);
                        return znode;
                }
        }

        RPT(RPT_INF, "search: no %d", key);
        return NULL;
}
Exemple #6
0
void zlst_set_name(void *ZNODE, const char *name)
{
        struct znode *znode;

        if(!ZNODE) {
                RPT(RPT_ERR, "set name: bad node");
                return;
        }
        znode = (struct znode *)ZNODE;

        RPT(RPT_INF, "set name: %s", name);
        znode->name = name; /* the string should be const */
        return;
}
Exemple #7
0
void zlst_set_key(void *ZNODE, int key)
{
        struct znode *znode;

        if(!ZNODE) {
                RPT(RPT_ERR, "set key: bad node");
                return;
        }
        znode = (struct znode *)ZNODE;

        RPT(RPT_INF, "set key: %d", key);
        znode->key = key;
        return;
}
Exemple #8
0
size_t udp_read(intptr_t id, void *buf)
{
        struct udp *udp = (struct udp *)id;

        if(NULL == udp) {
                RPT(RPT_ERR, "bad id");
                return -1;
        }

        size_t rslt = 0;
        fd_set fds;

        FD_ZERO(&fds);
        FD_SET(udp->sock, &fds);
        if(select(udp->sock + 1, &fds, NULL, NULL, NULL) < 0) {
                report("select failed");
                return 0;
        }

        if(FD_ISSET(udp->sock, &fds)) {
                rslt = recvfrom(udp->sock, buf, UDP_LENGTH_MAX, 0,
                                (struct sockaddr *)&(udp->remote),
                                &(udp->socklen));
        }

        return rslt;
}
Exemple #9
0
int main(int argc, char *argv[])
{
        unsigned char bbuf[ 204 + 10]; /* bin data buffer */
        char tbuf[1024 + 10]; /* txt data buffer */

        if(0 != deal_with_parameter(argc, argv)) {
                return -1;
        }

        fd_i = url_open(file_i, "rb");
        if(NULL == fd_i) {
                RPT(RPT_ERR, "open \"%s\" failed", file_i);
                return -1;
        }

        pkt_addr = 0;
        while(1 == url_read(bbuf, npline, 1, fd_i)) {
                fprintf(stdout, "*ts, ");
                b2t(tbuf, bbuf, 188);
                fprintf(stdout, "%s", tbuf);

                fprintf(stdout, "*addr, %llX, \n", pkt_addr);

                pkt_addr += npline;
        }

        url_close(fd_i);

        return 0;
}
Exemple #10
0
static int deal_with_parameter(int argc, char *argv[])
{
        int i;

        if(1 == argc) {
                /* no parameter */
                fprintf(stderr, "No URL to process...\n\n");
                show_help();
                return -1;
        }

        for(i = 1; i < argc; i++) {
                if('-' == argv[i][0]) {
                        if(0 == strcmp(argv[i], "-h") ||
                           0 == strcmp(argv[i], "--help")) {
                                show_help();
                                return -1;
                        }
                        else if(0 == strcmp(argv[i], "-v") ||
                                0 == strcmp(argv[i], "--version")) {
                                show_version();
                                return -1;
                        }
                        else {
                                RPT(RPT_ERR, "wrong parameter: %s", argv[i]);
                                return -1;
                        }
                }
                else {
                        strcpy(file_i, argv[i]);
                }
        }

        return 0;
}
Exemple #11
0
int udp_close(intptr_t id)
{
        struct udp *udp = (struct udp *)id;

        if(NULL == udp) {
                RPT(RPT_ERR, "bad id");
                return -1;
        }

        /* manage multicast */
        if(IN_MULTICAST(ntohl(inet_addr(udp->addr)))) {
                if('\0' == udp->src_addr[0]) {
                        struct ip_mreq imreq;

                        RPT(RPT_INF, "IP_DROP_MEMBERSHIP: %s", udp->addr);
                        imreq.imr_interface.s_addr = htonl(INADDR_ANY);
                        imreq.imr_multiaddr.s_addr = inet_addr(udp->addr);
                        if(setsockopt(udp->sock, IPPROTO_IP, IP_DROP_MEMBERSHIP,
                                      (char *)&imreq, sizeof(imreq)) != 0) {
                                report("IP_DROP_MEMBERSHIP failed");
                        }
                }
                else {
                        struct ip_mreq_source mreqsrc;

                        RPT(RPT_INF, "IP_DROP_SOURCE_MEMBERSHIP: %s@%s", udp->src_addr, udp->addr);
                        mreqsrc.imr_interface.s_addr = htonl(INADDR_ANY);
                        mreqsrc.imr_multiaddr.s_addr = inet_addr(udp->addr);
                        mreqsrc.imr_sourceaddr.s_addr = inet_addr(udp->src_addr);
                        if(setsockopt(udp->sock, IPPROTO_IP, IP_DROP_SOURCE_MEMBERSHIP,
                                      (char *)&mreqsrc, sizeof(mreqsrc)) != 0) {
                                report("IP_DROP_SOURCE_MEMBERSHIP failed");
                        }
                }
        }

        /* close socket*/
#ifdef SYS_WINDOWS
        closesocket(udp->sock);
        WSACleanup();
#else
        close(udp->sock);
#endif

        free(udp);
        return 0;
}
Exemple #12
0
/* if not return 0, it's up to the caller to free the uninserted node! */
int zlst_insert(void *PHEAD, void *ZNODE)
{
        struct znode *head;
        struct znode *znode;

        if(!ZNODE) {
                RPT(RPT_ERR, "insert: bad node");
                return -1;
        }
        znode = (struct znode *)ZNODE;

        if(!PHEAD) {
                RPT(RPT_ERR, "insert: NOT a list");
                return -1;
        }
        head = *(struct znode **)PHEAD;

        if(!head) {
                RPT(RPT_INF, "insert: into empty list");
                znode->tail = znode;
                znode->next = NULL;
                znode->prev = NULL;
                *(struct znode **)PHEAD = znode;
                return 0;
        }

        if(head->key > znode->key) {
                RPT(RPT_INF, "insert: %d as head before %d", znode->key, head->key);
                znode->tail = head->tail;
                znode->next = head;
                znode->prev = NULL;
                head->prev = znode;
                *(struct znode **)PHEAD = znode;
                return 0;
        }

        for(struct znode *x = head; x; x = x->next) {
                if(x->key == znode->key) {
                        RPT(RPT_INF, "insert: %d in list already", znode->key);
                        return -1;
                }

                if(x->key > znode->key) {
                        RPT(RPT_INF, "insert: %d before %d", znode->key, x->key);
                        znode->next = x;
                        znode->prev = x->prev;
                        x->prev->next = znode;
                        x->prev = znode;
                        return 0;
                }
        }

        RPT(RPT_INF, "insert: %d as tail after %d", znode->key, head->tail->key);
        znode->next = NULL;
        znode->prev = head->tail;
        head->tail->next = znode;
        head->tail = znode;
        return 0;
}
Exemple #13
0
inline std::pair< std::map< std::string, int >, RestartSchedule >
RPTSCHED( const DeckKeyword& keyword ) {
    auto mnemonics = RPT( keyword, is_RPTSCHED_mnemonic, RPTSCHED_integer );

    if( mnemonics.count( "NOTHING" ) )
        return { std::move( mnemonics ), { 0 } };

    if( mnemonics.count( "RESTART" ) )
        return { std::move( mnemonics ), size_t( mnemonics.at( "RESTART" ) ) };

    return { std::move( mnemonics ), {} };
}
Exemple #14
0
static int report(const char *str)
{
        int err;

#ifdef SYS_WINDOWS
        err = WSAGetLastError();
#else
        err = errno;
#endif
        RPT(RPT_ERR, "%s, errno: %d", str, err);
        return 0;
}
Exemple #15
0
inline std::pair< std::map< std::string, int >, RestartSchedule >
RPTRST( const DeckKeyword& keyword, RestartSchedule prev, size_t step ) {
    auto mnemonics = RPT( keyword, is_RPTRST_mnemonic, RPTRST_integer );

    const bool has_freq  = mnemonics.find( "FREQ" )  != mnemonics.end();
    const bool has_basic = mnemonics.find( "BASIC" ) != mnemonics.end();

    expand_RPTRST_mnemonics( mnemonics );

    if( !has_freq && !has_basic ) return { std::move( mnemonics ), {} };

    const auto basic = has_basic ? mnemonics.at( "BASIC" ) : prev.basic;
    const auto freq  = has_freq  ? mnemonics.at( "FREQ"  ) : prev.frequency;

    return { std::move( mnemonics ), { step, basic, freq } };
}
Exemple #16
0
size_t udp_write(intptr_t id, const void *buf, int len)
{
        struct udp *udp = (struct udp *)id;

        if(NULL == udp) {
                RPT(RPT_ERR, "bad id");
                return -1;
        }

        size_t rslt = 0;
        rslt = sendto(udp->sock, buf, len, 0,
                        (struct sockaddr *)&(udp->remote),
                        udp->socklen);

        return rslt;
}
Exemple #17
0
/* it's up to the caller to free the node! */
void *zlst_delete(void *PHEAD, void *ZNODE)
{
        struct znode *head;
        struct znode *znode;

        if(!ZNODE) {
                RPT(RPT_ERR, "delete: bad node");
                return NULL;
        }
        znode = (struct znode *)ZNODE;

        if(!PHEAD) {
                RPT(RPT_ERR, "delete: NOT a list");
                return NULL;
        }
        head = *(struct znode **)PHEAD;

        if(!head) {
                RPT(RPT_ERR, "delete: from an empty list");
                return znode; /* free the node please */
        }

        if(!(znode->prev) && !(znode->next)) {
                RPT(RPT_INF, "delete: from one node list");
                *(struct znode **)PHEAD = NULL;
                return znode;
        }

        if(!(znode->prev) && (znode->next)) {
                RPT(RPT_INF, "delete: head node");
                znode->next->tail = znode->tail;
                znode->next->prev = NULL;
                *(struct znode **)PHEAD = znode->next;
                return znode;
        }

        if((znode->prev) && !(znode->next)) {
                RPT(RPT_INF, "delete: tail node");
                head->tail = znode->prev;
                znode->prev->next = NULL;
                return znode;
        }

        /* (znode->prev) && (znode->next) */
        RPT(RPT_INF, "delete: ok");
        znode->prev->next = znode->next;
        znode->next->prev = znode->prev;
        return znode;
}
// The function programs the CSP of the radio module.
// The CSP can run programs of up to 24 instructions.
// Each instruction is written to register RFST in execution order
void rf_prog()
{
//  RFST = LABEL;         //set next instruction as start of loop
//  RFST = SKIP(1,0,5);   //skip 1 instructions if condition 5 (CSPY==0) applies (n=0) 
//  RFST = STXON;         //start TX
//  RFST = WAITX;         //wait for MAC TIMER to overflow no. of times set in CSPX
//  RFST = SRFOFF;        //stop TX/RX
//  RFST = WAIT(31);      //wait for MAC TIMER to overflow 10 times
//  RFST = DECY;          //CSPY--
//  RFST = SKIP(1,1,5);   //skip 1 instructions if condition 5 (CSPY==0) doesn't apply (n=1)
//  RFST = SKIP(0,0,5);   //if(y==0) wait for value of CSPY to update
//  RFST = RPT(0,6);      //goto start of loop if condition 6 (CSPZ==0) applies (n=0)
  
  RFST = LABEL;         //set next instruction as start of loop
  RFST = SKIP(1,0,5);   //skip 1 instructions if condition 5 (CSPY==0) applies (n=0) 
  RFST = STXON;         //start TX
  RFST = WEVENT1;       //wait for TIMER2 event1
  RFST = SRFOFF;        //stop TX/RX
  RFST = WEVENT2;       //wait for TIMER2 event2
  RFST = DECY;          //CSPY--
  RFST = RPT(0,6);      //goto start of loop if condition 6 (CSPZ==0) applies (n=0)
}
Exemple #19
0
intptr_t udp_open(char *src_addr, char *addr, unsigned short port, char *mode)
{
        struct udp *udp;

        udp = (struct udp *)malloc(sizeof(struct udp));
        if(NULL == udp) {
                RPT(RPT_ERR, "malloc failed");
                return (intptr_t)NULL;
        }

        strcpy(udp->addr, addr);

        udp->src_addr[0] = '\0';
        if(src_addr) {
                strcpy(udp->src_addr, src_addr);
        }

#ifdef SYS_WINDOWS
        WSADATA wsaData;
        if(WSAStartup(MAKEWORD(1,1), &wsaData) == SOCKET_ERROR)
        {
                RPT(RPT_ERR, "WSAStartup error");
                return (intptr_t)NULL;
        }
#endif

        /* build socket */
        if((udp->sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
                report("socket failed");
                return (intptr_t)NULL;
        }

        /* nonblock mode */
#ifdef SYS_WINDOWS
        {
                unsigned long opt = 1;
                ioctlsocket(udp->sock, FIONBIO, &opt);
        }
#else
        {
                fcntl(udp->sock, F_SETFL, O_NONBLOCK);
        }
#endif

        /* reuse address */
        {
                int reuseaddr = 1; /* nonzero means enable */

                setsockopt(udp->sock, SOL_SOCKET, SO_REUSEADDR,
                           (char *)&reuseaddr, sizeof(int));
        }

        /* name the socket */
        {
                struct sockaddr_in local;

                memset(&local, 0, sizeof(local)); /* for some special compile environment */
                local.sin_family = AF_INET;
                local.sin_addr.s_addr = htonl(INADDR_ANY);
                local.sin_port = ('r' == mode[0]) ? htons(port) : 0;

                if(bind(udp->sock, (struct sockaddr *)&local, sizeof(struct sockaddr)) < 0) {
                        report("bind failed");
                        fprintf(stderr, "addr: %s, port: %d\n",
                            inet_ntoa(local.sin_addr),
                            ntohs(local.sin_port));
                        return (intptr_t)NULL;
                }
        }

        /* set the remote */
        if('w' == mode[0])
        {
                udp->remote.sin_family = AF_INET;
                udp->remote.sin_addr.s_addr = inet_addr(addr);
                udp->remote.sin_port = htons(port);
        }

        /* manage multicast */
        if(IN_MULTICAST(ntohl(inet_addr(udp->addr)))) {
                if('\0' == udp->src_addr[0]) {
                        struct ip_mreq imreq;

                        RPT(RPT_INF, "IP_ADD_MEMBERSHIP: %s", udp->addr);
                        imreq.imr_interface.s_addr = htonl(INADDR_ANY);
                        imreq.imr_multiaddr.s_addr = inet_addr(udp->addr);
                        if(setsockopt(udp->sock, IPPROTO_IP, IP_ADD_MEMBERSHIP,
                                      (char *)&imreq, sizeof(imreq)) != 0) {
                                report("IP_ADD_MEMBERSHIP failed");
                        }
                }
                else {
                        struct ip_mreq_source mreqsrc;

                        RPT(RPT_INF, "IP_ADD_SOURCE_MEMBERSHIP: %s@%s", udp->src_addr, udp->addr);
                        mreqsrc.imr_interface.s_addr = htonl(INADDR_ANY);
                        mreqsrc.imr_multiaddr.s_addr = inet_addr(udp->addr);
                        mreqsrc.imr_sourceaddr.s_addr = inet_addr(udp->src_addr);
                        if(setsockopt(udp->sock, IPPROTO_IP, IP_ADD_SOURCE_MEMBERSHIP,
                                      (char *)&mreqsrc, sizeof(mreqsrc)) != 0) {
                                report("IP_ADD_SOURCE_MEMBERSHIP failed");
                        }
                }
        }

        udp->socklen = sizeof(struct sockaddr_in);
        return (intptr_t)udp;
}