test-sdludp.c

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

void attach_req(int fd, ppa_t *ppap) {
    ctrl.len = sizeof(cmd.lmi.attach_req)+sizeof(ppa_t);
    cmd.prim = LMI_ATTACH_REQ;
    bcopy(ppap, cmd.lmi.attach_req.lmi_ppa, sizeof(ppa_t));
    printf("\n%d-LMI_ATTACH_REQ\n",fd);
    print_ppa((ppa_t *)cmd.lmi.attach_req.lmi_ppa);
    put_and_get(fd, RS_HIPRI);
}

void detach_req(int fd) {
    ctrl.len = sizeof(cmd.lmi.detach_req);
    cmd.prim = LMI_DETACH_REQ;
    printf("\n%d-LMI_DETACH_REQ\n",fd);
    put_and_get(fd, RS_HIPRI);
}

void enable_req(int fd) {
    ctrl.len = sizeof(cmd.lmi.enable_req);
    cmd.prim = LMI_ENABLE_REQ;
    printf("\n%d-LMI_ENABLE_REQ\n",fd);
    put_and_get(fd, RS_HIPRI);
}

void disable_req(int fd) {
    ctrl.len = sizeof(cmd.lmi.disable_req);
    cmd.prim = LMI_DISABLE_REQ;
    printf("\n%d-LMI_DISABLE_REQ\n",fd);
    put_and_get(fd, RS_HIPRI);
}

int sdl_open(void) {
    int fd;
    printf("\nOPEN: ss7-sdl-udp0\n");
    if ( (fd = open("/dev/ss7-sdl-udp0",O_NONBLOCK|O_RDWR)) < 0 ) {
        printf("ERROR: open: [%d] %s\n", errno, strerror(errno));
        exit(2);
    }
    return(fd);
}

void sdl_close(int fd) {
    printf("\n%d-CLOSE\n",fd);
    if ( close(fd) < 0 ) {
        printf("ERROR: close: [%d] %s\n", errno, strerror(errno));
        return;
    }
}

void sdl_write(int fd) {
    const char msg[] = "Hello World!";
    dbuf[0] = 0xff;
    dbuf[1] = 0xff;
    dbuf[2] = sizeof(msg)-1;
    memcpy(&dbuf[3],msg,sizeof(msg)-1);
    printf("\n%d-WRITE %s (%d bytes)\n",fd, msg, sizeof(msg)+2);
    if ( write(fd, dbuf, sizeof(msg)+2) < 0 ) {
        printf("ERROR: write: [%d] %s\n", errno, strerror(errno));
        return;
    }
//  ctrl.len = sizeof(cmd.sdl.daedt_transmission_req);
//  cmd.prim = SDL_DAEDT_TRANSMISSION_REQ;
//  data.len = sizeof(msg)+2;
//  if ( putmsg(fd, &ctrl, &data, 0) < 0 ) {
//      printf("ERROR: putmsg: [%d] %s\n", errno, strerror(errno));
//      return;
//  }
}

void sdl_read(int fd) {
    int n;
//  int flags = 0;
    char *c = &dbuf[3];
    printf("\n%d-READ\n",fd);
    if ( (n = read(fd, dbuf, BUFSIZE)) < 0 ) {
        printf("ERROR: read: [%d] %s\n", errno, strerror(errno));
        return;
    }
//  if ( getmsg(fd, NULL, &data, &flags) < 0 ) {
//      printf("ERROR: getmsg: [%d] %s\n", errno, strerror(errno));
//      return;
//  }
//  n = data.len;
    printf("%d-READ Message[%d]: ",fd, n);
    for (n-=3;n>0;n--) printf("%c", *(c++));
    printf("\n");
}

void sdl_daedt_start(int fd) {
    ctrl.len = sizeof(cmd.sdl.daedt_start_req);
    cmd.prim = SDL_DAEDT_START_REQ;
    printf("\n%d-SDL_DAEDT_START_REQ\n",fd);
    put_and_get(fd, RS_HIPRI);
}

void sdl_daedr_start(int fd) {
    ctrl.len = sizeof(cmd.sdl.daedr_start_req);
    cmd.prim = SDL_DAEDR_START_REQ;
    printf("\n%d-SDL_DAEDR_START_REQ\n",fd);
    put_and_get(fd, RS_HIPRI);
}

int sdl_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("ERROR: ioctl: (rtn = %d) [%d] %s\n", ret, errno, strerror(errno));
        return ret;
    }
    return ctl.ic_len;
}

void do_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;
    sdl_ioctl(fd, SDL_IOCSCONFIG, buf, sizeof(sdl_config_t));
    sdl_ioctl(fd, SDL_IOCGCONFIG, buf, sizeof(sdl_config_t));
    printf("Config:\n");
    printf("  N = %lu\n", c->N);
    printf("  m = %lu\n", c->m);
    sdl_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");
    sdl_ioctl(fd, DEV_IOCGIFFLAGS, buf, sizeof(unsigned long));
    printf("  ifflags = %lu\n", *((unsigned long *)buf));
    sdl_ioctl(fd, DEV_IOCGIFTYPE, buf, sizeof(unsigned long));
    printf("  iftype = %lu\n", *((unsigned long *)buf));
    sdl_ioctl(fd, DEV_IOCGGRPTYPE, buf, sizeof(unsigned long));
    printf("  ifgtype = %lu\n", *((unsigned long *)buf));
    sdl_ioctl(fd, DEV_IOCGIFMODE, buf, sizeof(unsigned long));
    printf("  ifmode = %lu\n", *((unsigned long *)buf));
    sdl_ioctl(fd, DEV_IOCGIFRATE, buf, sizeof(unsigned long));
    printf("  ifrate = %lu\n", *((unsigned long *)buf));
    sdl_ioctl(fd, DEV_IOCGIFCLOCK, buf, sizeof(unsigned long));
    printf("  ifclock = %lu\n", *((unsigned long *)buf));
    sdl_ioctl(fd, DEV_IOCGIFCODING, buf, sizeof(unsigned long));
    printf("  ifcoding = %lu\n", *((unsigned long *)buf));
    sdl_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 = sdl_open();
    fd2 = sdl_open();

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

    info_req(fd1);
    attach_req(fd1, &ppa1);
    info_req(fd1);
    enable_req(fd1);
    info_req(fd1);

    info_req(fd2);
    attach_req(fd2, &ppa2);
    info_req(fd2);
    enable_req(fd2);
    info_req(fd2);

    do_ioctls(fd1);

    sdl_daedt_start(fd1);
    sdl_daedr_start(fd1);
    sdl_daedt_start(fd2);
    sdl_daedr_start(fd2);

    do_ioctls(fd2);

    sdl_write(fd1);
    sdl_write(fd1);
    sdl_write(fd1);
    sdl_write(fd1);
    sdl_write(fd1);
    sdl_write(fd1);
    sdl_write(fd1);
    sdl_write(fd1);
    sdl_write(fd1);
    sdl_write(fd1);
    sdl_write(fd1);

//  do_lmi_get_msg(fd1);
//  do_lmi_get_msg(fd2);
    
    sdl_read(fd2);
    sdl_read(fd2);
    sdl_read(fd2);
    sdl_read(fd2);
    sdl_read(fd2);
    sdl_read(fd2);
    sdl_read(fd2);
    sdl_read(fd2);
    sdl_read(fd2);
    sdl_read(fd2);
    sdl_read(fd2);

    disable_req(fd1);
    info_req(fd1);
    detach_req(fd1);
    info_req(fd1);

    disable_req(fd2);
    info_req(fd2);
    detach_req(fd2);
    info_req(fd2);

    sdl_close(fd1);
    sdl_close(fd2);

    printf("Done.\n");

    return(0);
}