test-sdt.c

No7信令,我需要交换类似的代码, 请店长审核,谢谢了,急着交换,谢谢

    if ( (ret = putmsg(fd, &ctrl, NULL, RS_HIPRI)) < 0 ) {
        printf("error = %d\n", errno);
        perror(__FUNCTION__);
        exit(2);
    } else
        printf("Putmsg succeeded!\n");
    test_lmi_getmsg(fd);
}

void test_enable_req(int fd) {
    int ret;
    struct strbuf ctrl;
    char cbuf[BUFSIZE];
    union LMI_primitives *p = (union LMI_primitives *)cbuf;
    ctrl.maxlen = BUFSIZE;
    ctrl.len    = sizeof(p->enable_req);
    ctrl.buf    = cbuf;
    p->lmi_primitive = LMI_ENABLE_REQ;
    printf("\nAttempting enable request\n");
    if ( (ret = putmsg(fd, &ctrl, NULL, RS_HIPRI)) < 0 ) {
        printf("error = %d\n", errno);
        perror(__FUNCTION__);
        exit(2);
    } else
        printf("Putmsg succeeded!\n");
    test_lmi_getmsg(fd);
}

void test_disable_req(int fd) {
    int ret;
    struct strbuf ctrl;
    char cbuf[BUFSIZE];
    union LMI_primitives *p = (union LMI_primitives *)cbuf;
    ctrl.maxlen = BUFSIZE;
    ctrl.len    = sizeof(p->disable_req);
    ctrl.buf    = cbuf;
    p->lmi_primitive = LMI_DISABLE_REQ;
    printf("\nAttempting disable request\n");
    if ( (ret = putmsg(fd, &ctrl, NULL, RS_HIPRI)) < 0 ) {
        printf("error = %d\n", errno);
        perror(__FUNCTION__);
        exit(2);
    } else
        printf("Putmsg succeeded!\n");
    test_lmi_getmsg(fd);
}

int test_open(void) {
    int fd;
    printf("\nAttempting to open ss7-sdl-udp0\n");
    if ( (fd = open("/dev/ss7-sdl-udp0",O_NONBLOCK|O_RDWR)) < 0 ) {
        printf("error = %d\n", errno);
        perror(__FUNCTION__);
        exit(2);
    } else
        printf("Open succeeded!\n");
    return(fd);
}

void test_push(int fd) {
    int ret;
    printf("\nAttempting to push streams-sdt\n");
    if ( (ret = ioctl(fd, I_PUSH, "sdt")) < 0 ) {
        printf("return = %d\n", ret);
        printf("error = %d\n", errno);
        perror(__FUNCTION__);
        exit(2);
    } else
        printf("Push succeeded!\n");
}

void test_close(int fd) {
    int ret;
    printf("\nAttempting to close ss7-sdl-udp0\n");
    if ( (ret = close(fd)) < 0 ) {
        printf("error = %d\n", errno);
        perror(__FUNCTION__);
        exit(2);
    } else
        printf("Close succeeded!\n");
}

void test_write(int fd) {
    char buf[] = "   Hello World!";
    int i;
    int ret;
    buf[0] = 0xff;
    buf[1] = 0xff;
    buf[2] = sizeof(buf)-4;
    for ( i=0; i<10; i++ ) {
        printf("\nAttempting write\n");
        ret = write(fd, buf, sizeof(buf)-1);
        if ( ret < 0 ) {
            printf("error = %d\n", errno);
            perror(__FUNCTION__);
            exit(2);
        } else
            printf("Write succeeded, wrote %d bytes!\n", ret);
    }
}

void test_daedt_start(int fd) {
    int ret;
    struct strbuf ctrl;
    char cbuf[BUFSIZE];
    union SDT_primitives *p = (union SDT_primitives *)cbuf;
    ctrl.maxlen = BUFSIZE;
    ctrl.len    = sizeof(p->daedt_start_req);
    ctrl.buf    = cbuf;
    p->sdt_primitive = SDT_DAEDT_START_REQ;
    printf("\nAttempting DAEDT start request\n");
    if ( (ret = putmsg(fd, &ctrl, NULL, RS_HIPRI)) < 0 ) {
        printf("error = %d\n", errno);
        perror(__FUNCTION__);
        exit(2);
    } else
        printf("Putmsg succeeded!\n");
    test_lmi_getmsg(fd);
}

void test_daedr_start(int fd) {
    int ret;
    struct strbuf ctrl;
    char cbuf[BUFSIZE];
    union SDT_primitives *p = (union SDT_primitives *)cbuf;
    ctrl.maxlen = BUFSIZE;
    ctrl.len    = sizeof(p->daedr_start_req);
    ctrl.buf    = cbuf;
    p->sdt_primitive = SDT_DAEDR_START_REQ;
    printf("\nAttempting DAEDR start request\n");
    if ( (ret = putmsg(fd, &ctrl, NULL, RS_HIPRI)) < 0 ) {
        printf("error = %d\n", errno);
        perror(__FUNCTION__);
        exit(2);
    } else
        printf("Putmsg succeeded!\n");
    test_lmi_getmsg(fd);
}

void test_read(int fd) {
    char buf[256];
    int i, ret;
    i = 0;
    printf("\nAttempting read\n");
    for (;;) {
        ret = read(fd, buf, 256);
        if ( ret < 0 ) {
            if ( errno == EAGAIN ) {
                if ( i++ < 100 )
                    continue;
            }
            printf("error = %d\n", errno);
            perror(__FUNCTION__);
            break;
        } else
            printf("Read succeeded, read %d bytes!\n", ret);
        if ( ret > 0 ) {
            int i;
            printf("Message[%d]: ", ret);
            for ( i=3; i<ret; i++ )
                printf("%c", buf[i]);
            printf("\n");
        }
    }
}

int test_ioctl(int fd, int cmd, void *arg, int len) {
    struct strioctl ctl = { cmd, 0, len, arg };
    int ret;
    ret = ioctl(fd, I_STR, &ctl);
    if ( ret < 0 ) {
        printf("return = %d\n", ret);
        printf("error = %d\n", errno);
        perror(__FUNCTION__);
        exit(2);
    }
    return ctl.ic_len;
}

void test_ioctls(int fd) {
    unsigned char buf[256];
    sdl_config_t *c = (sdl_config_t *)buf;
    sdl_statem_t *s = (sdl_statem_t *)buf;
    printf("\nAttempting ioctls\n");
    c->N = 16;
    c->m = 272;
    test_ioctl(fd, SDL_IOCSCONFIG, buf, sizeof(sdl_config_t));
    test_ioctl(fd, SDL_IOCGCONFIG, buf, sizeof(sdl_config_t));
    printf("Config:\n");
    printf("  N = %lu\n", c->N);
    printf("  m = %lu\n", c->m);
    test_ioctl(fd, SDL_IOCGSTATEM, buf, sizeof(sdl_statem_t));
    printf("State:\n");
    printf("  daedt_state = %lu\n", s->daedt_state);
    printf("  daedr_state = %lu\n", s->daedr_state);
    printf("  octet_counting_mode = %lu\n", s->octet_counting_mode);
    printf("Iface:\n");
    test_ioctl(fd, DEV_IOCGIFFLAGS, buf, sizeof(unsigned long));
    printf("  ifflags = %lu\n", *((unsigned long *)buf));
    test_ioctl(fd, DEV_IOCGIFTYPE, buf, sizeof(unsigned long));
    printf("  iftype = %lu\n", *((unsigned long *)buf));
    test_ioctl(fd, DEV_IOCGGRPTYPE, buf, sizeof(unsigned long));
    printf("  ifgtype = %lu\n", *((unsigned long *)buf));
    test_ioctl(fd, DEV_IOCGIFMODE, buf, sizeof(unsigned long));
    printf("  ifmode = %lu\n", *((unsigned long *)buf));
    test_ioctl(fd, DEV_IOCGIFRATE, buf, sizeof(unsigned long));
    printf("  ifrate = %lu\n", *((unsigned long *)buf));
    test_ioctl(fd, DEV_IOCGIFCLOCK, buf, sizeof(unsigned long));
    printf("  ifclock = %lu\n", *((unsigned long *)buf));
    test_ioctl(fd, DEV_IOCGIFCODING, buf, sizeof(unsigned long));
    printf("  ifcoding = %lu\n", *((unsigned long *)buf));
    test_ioctl(fd, DEV_IOCGIFLEADS, buf, sizeof(unsigned long));
    printf("  ifleads = %lu\n", *((unsigned long *)buf));
}

int main () {
    int fd1, fd2;
    ppa_t ppa1, ppa2;
    printf("Simple test program for ss7-sdl-udp driver.\n");

    ppa1.loc.sin_family = AF_INET;
    ppa1.loc.sin_port = 10000;
    ppa1.loc.sin_addr.s_addr = INADDR_ANY;
    ppa1.rem.sin_family = AF_INET;
    ppa1.rem.sin_port = 10001;
    inet_aton("127.0.0.1",&ppa1.rem.sin_addr);

    ppa2.loc.sin_family = AF_INET;
    ppa2.loc.sin_port = 10001;
    ppa2.loc.sin_addr.s_addr = INADDR_ANY;
    ppa2.rem.sin_family = AF_INET;
    ppa2.rem.sin_port = 10000;
    inet_aton("127.0.0.1",&ppa2.rem.sin_addr);

    fd1 = test_open();
    fd2 = test_open();

    ioctl(fd1, I_SRDOPT, RMSGD|RPROTDIS);
    ioctl(fd2, I_SRDOPT, RMSGD|RPROTDIS);

    test_push(fd1);
    test_push(fd2);

    test_info_req(fd1);
    test_attach_req(fd1, &ppa1);
    test_info_req(fd1);
    test_enable_req(fd1);
    test_info_req(fd1);

    test_info_req(fd2);
    test_attach_req(fd2, &ppa2);
    test_info_req(fd2);
    test_enable_req(fd2);
    test_info_req(fd2);

    test_ioctls(fd1);

    test_daedt_start(fd1);
    test_daedr_start(fd1);
    test_daedt_start(fd2);
    test_daedr_start(fd2);

    test_ioctls(fd2);

    test_write(fd1);

    test_lmi_getmsg(fd1);
    test_lmi_getmsg(fd2);
    
    test_read(fd2);

    test_disable_req(fd1);
    test_info_req(fd1);
    test_detach_req(fd1);
    test_info_req(fd1);

    test_disable_req(fd2);
    test_info_req(fd2);
    test_detach_req(fd2);
    test_info_req(fd2);

    test_close(fd1);
    test_close(fd2);

    printf("Done.\n");

    return(0);
}