xpp: fix manpage of astribank_hexload
[dahdi/tools.git] / hdlcgen.c
1 /*
2  * Written by Mark Spencer <markster@digium.com>
3  * Based on previous works, designs, and architectures conceived and
4  * written by Jim Dixon <jim@lambdatel.com>.
5  *
6  * Copyright (C) 2001 Jim Dixon / Zapata Telephony.
7  * Copyright (C) 2001-2008 Digium, Inc.
8  *
9  * All rights reserved.
10  *
11  * Primary Author: Mark Spencer <markster@digium.com>
12  * Radio Support by Jim Dixon <jim@lambdatel.com>
13  */
14
15 /*
16  * See http://www.asterisk.org for more information about
17  * the Asterisk project. Please do not directly contact
18  * any of the maintainers of this project for assistance;
19  * the project provides a web site, mailing lists and IRC
20  * channels for your use.
21  *
22  * This program is free software, distributed under the terms of
23  * the GNU General Public License Version 2 as published by the
24  * Free Software Foundation. See the LICENSE file included with
25  * this program for more details.
26  */
27
28 #include <stdio.h>
29 #include <fcntl.h>
30 #include <string.h>
31 #include <errno.h>
32 #include <unistd.h>
33 #include <stdlib.h>
34
35 #define FAST_HDLC_NEED_TABLES
36 #include <dahdi/fasthdlc.h>
37
38 #include "dahdi_tools_version.h"
39
40 #define RANDOM "/dev/urandom"                   /* Not genuinely random */
41 /* #define RANDOM "/dev/random" */              /* Quite genuinely random */
42
43 int myread(int fd, char *buf, int len)
44 {
45         int sofar;
46         int res;
47         sofar = 0;
48         while(sofar < len) {
49                 res = read(fd, buf + sofar, len - sofar);
50                 if (res < 0)
51                         return res;
52                 sofar += res;
53         }
54         return sofar;
55 }
56
57 int main(int argc, char *argv[])
58 {
59         unsigned char buf[1024];
60         unsigned char outbuf[2048];
61         int res;
62         int randin;
63         int randout;
64         int hdlcout;
65         int cnt;
66         int hdlccnt;
67         int x;
68         int flags;
69         struct fasthdlc_state transmitter;
70         
71         fasthdlc_precalc();
72         
73         fasthdlc_init(&transmitter, FASTHDLC_MODE_64);
74         
75         randin = open(RANDOM, O_RDONLY);
76         if (randin < 0) {
77                 fprintf(stderr, "Unable to open %s: %s\n", RANDOM, strerror(errno));
78                 exit(1);
79         }
80         randout = open("random.raw", O_WRONLY|O_TRUNC|O_CREAT, 0666);
81         if (randout < 0) {
82                 fprintf(stderr, "Unable to open random.raw: %s\n", strerror(errno));
83                 exit(1);
84         }
85         hdlcout = open("random.hdlc", O_WRONLY|O_TRUNC|O_CREAT, 0666);
86         if (hdlcout < 0) {
87                 fprintf(stderr, "Unable to open random.hdlc: %s\n", strerror(errno));
88                 exit(1);
89         }
90         for (;;) {
91                 cnt = (rand() % 256) + 4;       /* Read a pseudo-random amount of stuff */
92                 res = myread(randin, buf, cnt);
93                 if (res != cnt) {
94                         fprintf(stderr, "Tried to read %d bytes, but read %d instead\n", cnt, res);
95                         exit(1);
96                 }
97                 res = write(randout, buf, cnt);
98                 if (res != cnt) {
99                         fprintf(stderr, "Tried to write %d bytes, but wrote %d instead\n", cnt, res);
100                         exit(1);
101                 }
102                 /* HDLC encode */
103                 hdlccnt = 0;
104                 /* Start with a flag */
105                 fasthdlc_tx_frame(&transmitter);
106                 if (transmitter.bits >= 8)
107                         outbuf[hdlccnt++] = fasthdlc_tx_run(&transmitter);
108                 for (x=0;x<cnt;x++) {
109                         res = fasthdlc_tx_load(&transmitter, buf[x]);
110                         if (res < 0) {
111                                 fprintf(stderr, "Unable to load byte :(\n");
112                                 exit(1);
113                         }
114                         while(transmitter.bits >= 8)  {
115                                 outbuf[hdlccnt++] = fasthdlc_tx_run(&transmitter);
116                         }
117                 }
118                 flags = (rand() % 4);
119                 for (x=0;x<flags;x++) {
120                         if (transmitter.bits < 8)
121                                 fasthdlc_tx_frame(&transmitter);
122                         else
123                                 fprintf(stderr, "Huh?  Don't need a frame?\n");
124                         outbuf[hdlccnt++] = fasthdlc_tx_run(&transmitter);
125                 }
126                 if (argc > 1)
127                         printf("Encoded %d byte message with %d bytes of HDLC and %d extra flags\n", cnt, hdlccnt, flags);
128                 res = write(hdlcout, outbuf, hdlccnt);
129                 if (res != hdlccnt) {
130                         fprintf(stderr, "Tried to write %d HDLC bytes, but wrote %d instead\n", cnt, res);
131                         exit(1);
132                 }
133                 
134         }
135 }