ldltest.c

7号信令功能代码,为开源代码

	    dl_ok_ack_t     ack;
	    unsigned char   extra[1024];
      } reply;
      int             flags;
      struct strbuf   ctlbuf;
      dl_error_ack_t *err_ack;

      if (verbose > 2)
	    printf("do_attach: Sending DL_ATTACH_REQ\n");

      request.dl_primitive = DL_ATTACH_REQ;
      request.dl_ppa = ppa;
      ctlbuf.maxlen = ctlbuf.len = sizeof(request);
      ctlbuf.buf = (char *) &request;
      if (verbose > 2) {
	    printf("do_attach: Attach_req buffer dump:\n");
	    dumpbuf(ctlbuf);
      }
      if (putmsg(fd, &ctlbuf, NULL, 0) < 0) {
	    perror("do_attach: putmsg()");
	    return -1;
      }

      ctlbuf.maxlen = sizeof(reply);
      ctlbuf.len = 0;
      ctlbuf.buf = (char *) &reply;
      flags = RS_HIPRI;
      if (getmsg(fd, &ctlbuf, NULL, &flags) < 0) {
	    perror("do_attach: getmsg()");
	    return -1;
      }

      if (verbose > 2) {
	    printf("do_attach: Buffer dump:\n");
	    dumpbuf(ctlbuf);
      }

      if (ctlbuf.len < sizeof(dl_ulong)) {
	    if (verbose)
		  fprintf(stderr, "do_attach: Bad reply length %d\n", ctlbuf.len);
	    return -1;
      }

      switch (reply.ack.dl_primitive) {
      case DL_ERROR_ACK:
	    if (verbose)
		  printf("do_attach: Got DL_ERROR_ACK\n");
	    if (ctlbuf.len < sizeof(dl_error_ack_t)) {
		  if (verbose)
			fprintf(stderr, "do_attach: Bad DL_ERROR_ACK length %d\n",
				ctlbuf.len);
		  return -1;
	    }
	    err_ack = (dl_error_ack_t *) & reply;
	    if (verbose) {
		  printf("do_attach: error ack:\n");
		  printf("\tprimitive=%lu, errno=%lu, unix_errno=%lu\n",
			 err_ack->dl_error_primitive, err_ack->dl_errno,
			 err_ack->dl_unix_errno);
	    }
	    return -1;

      case DL_OK_ACK:
	    if (verbose > 2)
		  printf("do_attach: Got DL_OK_ACK\n");
	    if (ctlbuf.len < sizeof(dl_ok_ack_t)) {
		  if (verbose)
			fprintf(stderr, "do_attach: Bad DL_OK_ACK length %d\n",
				ctlbuf.len);
		  return -1;
	    }
	    if (verbose > 1) {
		  printf("do_attach: ok ack:\n");
		  printf("\tprimitive=%lu\n", reply.ack.dl_primitive);
		  printf("\tcorrect_primitive=%lu\n", reply.ack.dl_correct_primitive);
	    }
	    break;

      default:
	    if (verbose)
		  fprintf(stderr, "do_attach: Unknown reply primitive=%lu\n",
			  reply.ack.dl_primitive);
	    return -1;
      }
      return 0;
}

int do_promiscon(int fd, unsigned long level)
{
      dl_promiscon_req_t request;
      struct {
	    dl_ok_ack_t     ack;
	    unsigned char   extra[1024];
      } reply;
      int             flags;
      struct strbuf   ctlbuf;
      dl_error_ack_t *err_ack;

      if (verbose > 2)
	    printf("do_promiscon: Sending DL_PROMISCON_REQ\n");

      request.dl_primitive = DL_PROMISCON_REQ;
      request.dl_level = level;
      ctlbuf.maxlen = ctlbuf.len = sizeof(request);
      ctlbuf.buf = (char *) &request;
      if (putmsg(fd, &ctlbuf, NULL, 0) < 0) {
	    perror("do_promiscon: putmsg()");
	    return -1;
      }

      ctlbuf.maxlen = sizeof(reply);
      ctlbuf.len = 0;
      ctlbuf.buf = (char *) &reply;
      flags = RS_HIPRI;
      if (getmsg(fd, &ctlbuf, NULL, &flags) < 0) {
	    perror("do_promiscon: getmsg()");
	    return -1;
      }

      if (verbose > 2) {
	    printf("do_promiscon: Buffer dump:\n");
	    dumpbuf(ctlbuf);
      }

      if (ctlbuf.len < sizeof(dl_ulong)) {
	    if (verbose)
		  fprintf(stderr, "do_promiscon: Bad reply length %d\n", ctlbuf.len);
	    return -1;
      }

      switch (reply.ack.dl_primitive) {
      case DL_ERROR_ACK:
	    if (verbose)
		  printf("do_promiscon: Got DL_ERROR_ACK\n");
	    if (ctlbuf.len < sizeof(dl_error_ack_t)) {
		  if (verbose)
			fprintf(stderr, "do_promiscon: Bad DL_ERROR_ACK length %d\n",
				ctlbuf.len);
		  return -1;
	    }
	    err_ack = (dl_error_ack_t *) & reply;
	    if (verbose) {
		  printf("do_promiscon: error ack:\n");
		  printf("\tprimitive=%lu, errno=%lu, unix_errno=%lu\n",
			 err_ack->dl_error_primitive, err_ack->dl_errno,
			 err_ack->dl_unix_errno);
	    }
	    return -1;

      case DL_OK_ACK:
	    if (verbose > 2)
		  printf("do_promiscon: Got DL_OK_ACK\n");
	    if (ctlbuf.len < sizeof(dl_ok_ack_t)) {
		  if (verbose)
			fprintf(stderr, "do_promiscon: Bad DL_OK_ACK length %d\n",
				ctlbuf.len);
		  return -1;
	    }
	    if (verbose > 1) {
		  printf("do_promiscon: ok ack:\n");
		  printf("\tprimitive=%lu\n", reply.ack.dl_primitive);
		  printf("\tcorrect_primitive=%lu\n", reply.ack.dl_correct_primitive);
	    }
	    if (reply.ack.dl_correct_primitive != request.dl_primitive) {
		  if (verbose)
			fprintf(stderr,
				"do_promiscon: " "DL_OK_ACK acks wrong primitive\n");
		  return -1;
	    }
	    break;

      default:
	    if (verbose)
		  fprintf(stderr, "do_promiscon: Unknown reply primitive=%lu\n",
			  reply.ack.dl_primitive);
	    return -1;
      }
      return 0;
}

int do_bind(int fd, dl_ulong sap)
{
      dl_bind_req_t   request;
      struct {
	    dl_bind_ack_t   ack;
	    unsigned char   extra[1024];
      } reply;
      int             flags;
      struct strbuf   ctlbuf;
      dl_error_ack_t *err_ack;

      if (verbose > 2)
	    printf("do_bind(sap=0x%lx): Sending DL_BIND_REQ\n", sap);

      request.dl_primitive = DL_BIND_REQ;
      request.dl_sap = sap;
      request.dl_max_conind = 0;
      request.dl_service_mode = DL_CLDLS;
      request.dl_conn_mgmt = 0;
      request.dl_xidtest_flg = 0;
      ctlbuf.maxlen = ctlbuf.len = sizeof(request);
      ctlbuf.buf = (char *) &request;
      if (putmsg(fd, &ctlbuf, NULL, 0) < 0) {
	    perror("do_bind: putmsg()");
	    return -1;
      }

      ctlbuf.maxlen = sizeof(reply);
      ctlbuf.len = 0;
      ctlbuf.buf = (char *) &reply;
      flags = RS_HIPRI;
      if (getmsg(fd, &ctlbuf, NULL, &flags) < 0) {
	    perror("do_bind: getmsg()");
	    return -1;
      }

      if (verbose > 2) {
	    printf("do_bind: Buffer dump:\n");
	    dumpbuf(ctlbuf);
      }

      if (ctlbuf.len < sizeof(dl_ulong)) {
	    if (verbose)
		  fprintf(stderr, "do_bind: Bad reply length %d\n", ctlbuf.len);
	    return -1;
      }

      switch (reply.ack.dl_primitive) {
      case DL_ERROR_ACK:
	    if (verbose)
		  printf("do_bind: Got DL_ERROR_ACK\n");
	    if (ctlbuf.len < sizeof(dl_error_ack_t)) {
		  if (verbose)
			fprintf(stderr, "do_bind: Bad DL_ERROR_ACK length %d\n",
				ctlbuf.len);
		  return -1;
	    }
	    err_ack = (dl_error_ack_t *) & reply;
	    if (verbose) {
		  printf("do_bind: error ack:\n");
		  printf("\tprimitive=%lu, errno=%lu, unix_errno=%lu\n",
			 err_ack->dl_error_primitive, err_ack->dl_errno,
			 err_ack->dl_unix_errno);
	    }
	    return -1;

      case DL_BIND_ACK:
	    if (verbose > 2)
		  printf("do_bind: Got DL_BIND_ACK\n");
	    if (ctlbuf.len < sizeof(dl_bind_ack_t)) {
		  if (verbose)
			fprintf(stderr, "do_bind: Bad DL_BIND_ACK length %d\n",
				ctlbuf.len);
		  return -1;
	    }
	    if (verbose > 1) {
		  printf("do_bind: bind ack:\n");
		  printf("\tprimitive=%lu\n", reply.ack.dl_primitive);
		  printf("\tsap=%lu\n", reply.ack.dl_sap);
		  printf("\taddr_length=%lu\n", reply.ack.dl_addr_length);
		  printf("\taddr_offset=%lu\n", reply.ack.dl_addr_offset);
		  printf("\tmax_conind=%lu\n", reply.ack.dl_max_conind);
		  printf("\txidtest_flg=%lu\n", reply.ack.dl_xidtest_flg);
		  dumpbytes("\tSAP", (char *) &reply.ack + reply.ack.dl_addr_offset,
			    reply.ack.dl_addr_length);
	    }
	    break;

      default:
	    if (verbose)
		  fprintf(stderr, "do_bind: Unknown reply primitive=%lu\n",
			  reply.ack.dl_primitive);
	    return -1;
      }
      return 0;
}

int do_bind_peer(int fd, char *sap, int saplen)
{
      struct {
	    dl_subs_bind_req_t req;
	    unsigned char   extra[1024];
      } request;
      struct {
	    dl_subs_bind_ack_t ack;
	    unsigned char   extra[1024];
      } reply;
      int             flags;
      struct strbuf   ctlbuf;
      dl_error_ack_t *err_ack;

      assert(saplen < 1024);

      if (verbose > 2)
	    printf("do_bind_peer: Sending DL_SUBS_BIND_REQ\n");

      request.req.dl_primitive = DL_SUBS_BIND_REQ;
      request.req.dl_subs_sap_length = saplen;
      request.req.dl_subs_sap_offset = sizeof(request.req);
      request.req.dl_subs_bind_class = DL_PEER_BIND;
      memcpy(request.extra, sap, saplen);

      ctlbuf.maxlen = sizeof(request);
      ctlbuf.len = sizeof(request.req) + saplen;
      ctlbuf.buf = (char *) &request;
      if (verbose > 2) {
	    printf("do_bind_peer: Buffer dump:\n");
	    dumpbuf(ctlbuf);
      }

      if (putmsg(fd, &ctlbuf, NULL, 0) < 0) {
	    perror("do_bind_peer: putmsg()");
	    return -1;
      }

      ctlbuf.maxlen = sizeof(reply);
      ctlbuf.len = 0;
      ctlbuf.buf = (char *) &reply;
      flags = RS_HIPRI;
      if (getmsg(fd, &ctlbuf, NULL, &flags) < 0) {
	    perror("do_bind_peer: getmsg()");
	    return -1;
      }

      if (verbose > 2) {
	    printf("do_bind_peer: Buffer dump:\n");
	    dumpbuf(ctlbuf);
      }

      if (ctlbuf.len < sizeof(dl_ulong)) {
	    if (verbose)
		  fprintf(stderr, "do_bind_peer: Bad reply length %d\n", ctlbuf.len);
	    return -1;
      }

      switch (reply.ack.dl_primitive) {
      case DL_ERROR_ACK:
	    if (verbose)
		  printf("do_bind_peer: Got DL_ERROR_ACK\n");
	    if (ctlbuf.len < sizeof(dl_error_ack_t)) {
		  if (verbose)
			fprintf(stderr, "do_bind_peer: Bad DL_ERROR_ACK length %d\n",
				ctlbuf.len);
		  return -1;
	    }
	    err_ack = (dl_error_ack_t *) & reply;
	    if (verbose) {
		  printf("do_bind_peer: error ack:\n");
		  printf("\tprimitive=%lu, errno=%lu, unix_errno=%lu\n",
			 err_ack->dl_error_primitive, err_ack->dl_errno,
			 err_ack->dl_unix_errno);
	    }
	    return -1;

      case DL_SUBS_BIND_ACK:
	    if (verbose > 2)
		  printf("do_bind_peer: Got DL_SUBS_BIND_ACK\n");
	    if (ctlbuf.len < sizeof(dl_subs_bind_ack_t)) {
		  if (verbose)
			fprintf(stderr, "do_bind_peer: Bad DL_BIND_ACK length %d\n",
				ctlbuf.len);
		  return -1;
	    }
	    if (verbose > 1) {
		  printf("do_bind_peer: subs_bind ack:\n");
		  printf("\tprimitive=%lu\n", reply.ack.dl_primitive);
		  printf("\tsap_length=%lu\n", reply.ack.dl_subs_sap_length);
		  printf("\tsap_offset=%lu\n", reply.ack.dl_subs_sap_offset);
		  dumpbytes("\tSAP", (char *) &reply.ack + reply.ack.dl_subs_sap_offset,
			    reply.ack.dl_subs_sap_length);
	    }
	    break;

      default:
	    if (verbose)
		  fprintf(stderr, "do_bind_peer: Unknown reply primitive=%lu\n",
			  reply.ack.dl_primitive);
	    return -1;
      }
      return 0;
}

int do_send_unitdata(int fd, unsigned char *data, int datalen, unsigned char *dlsap)
{
      struct {
	    struct ethhdr hdr __attribute__ ((packed));
	    char            data[4096] __attribute__ ((packed));
      } pkt;
      struct strbuf   ctlbuf,
                      databuf;
      struct {
	    dl_unitdata_req_t req;
	    unsigned char   extra[1024];
      } request;

      assert(datalen < 4096);

      if (verbose > 1)
	    printf("do_send_unitdata: sending unitdata.\n");

      memcpy(pkt.data, data, datalen);

      if (ldl_flags & LDLFLAG_RAW) {
	    databuf.maxlen = sizeof(pkt);
	    databuf.len = sizeof(pkt.hdr) + datalen;
	    databuf.buf = (char *) &pkt;

	    /*
	     * Fill in header 
	     */
	    assert(addr_len == ETH_ALEN);
	    assert(sap_len == 2);
	    memcpy(pkt.hdr.h_source, my_addr, ETH_ALEN);

	    memcpy(&pkt.hdr.h_proto, dlsap_sap(dlsap), sap_len);
	    memcpy(pkt.hdr.h_dest, dlsap_addr(dlsap), addr_len);

	    if (verbose > 2) {
		  printf("do_send_unitdata: Buffer dump RAW data:\n");
		  dumpbuf(databuf);
	    }

	    if (putmsg(fd, NULL, &databuf, 0) < 0) {
		  perror("do_send_unitdata: putmsg()");
		  return -1;
	    }
      }
      else {
	    databuf.maxlen = sizeof(pkt.data);
	    databuf.len = datalen;
	    databuf.buf = pkt.data;

	    ctlbuf.maxlen = sizeof(request);
	    ctlbuf.len = sizeof(request.req) + addr_len + sap_len;
	    ctlbuf.buf = (char *) &request;

	    request.req.dl_primitive = DL_UNITDATA_REQ;
	    request.req.dl_dest_addr_length = addr_len + sap_len;
	    request.req.dl_dest_addr_offset = sizeof(dl_unitdata_req_t);
	    request.req.dl_priority.dl_min = DL_QOS_DONT_CARE;
	    request.req.dl_priority.dl_max = DL_QOS_DONT_CARE;
	    request.req.dl_priority.dl_min = 50;
	    request.req.dl_priority.dl_max = 50;
	    memcpy(request.extra, dlsap, addr_len + sap_len);

	    if (verbose > 2) {
		  printf("do_send_unitdata: Buffer ctl data:\n");
		  dumpbuf(ctlbuf);
		  printf("do_send_unitdata: Buffer dump data:\n");
		  dumpbuf(databuf);
	    }

	    if (putmsg(fd, &ctlbuf, &databuf, 0) < 0) {
		  perror("do_send_unitdata: putmsg()");
		  return -1;
	    }
      }
      if (verbose > 1)
	    printf("do_send_unitdata: sent unitdata.\n");