URL https://opencores.org/ocsvn/xulalx25soc/xulalx25soc/trunk

Subversion Repositories xulalx25soc

[/] [xulalx25soc/] [trunk/] [sw/] [netusb.cpp] - Blame information for rev 84

Go to most recent revision | Details | Compare with Previous | View Log


////////////////////////////////////////////////////////////////////////////////
//
// Filename:    netusb.cpp
//
// Project:     XuLA2 board
//
// Purpose:     Forwards a XuLA2 board USB connection over a TCP socket, so
//              a non-local computer can control the board.
//
//
// Creator:     Dan Gisselquist, Ph.D.
//              Gisselquist Technology, LLC
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of  the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License, or (at
// your option) any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
// for more details.
//
// License:     GPL, v3, as defined and found on www.gnu.org,
//              http://www.gnu.org/licenses/gpl.html
//
//
////////////////////////////////////////////////////////////////////////////////
//
//
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>
#include <poll.h>
#include <signal.h>
#include <ctype.h>
#include <assert.h>
#include <errno.h>
 
#include "port.h"
#include "usbi.h"
 
void    sigstop(int v) {
        fprintf(stderr, "SIGSTOP!!\n");
        exit(0);
}
void    sighup(int v) {
        fprintf(stderr, "SIGHUP!!\n");
        exit(0);
}
void    sigint(int v) {
        fprintf(stderr, "SIGINT!!\n");
        exit(0);
}
void    sigsegv(int v) {
        fprintf(stderr, "SIGSEGV!!\n");
        exit(0);
}
void    sigbus(int v) {
        fprintf(stderr, "SIGBUS!!\n");
        exit(0);
}
void    sigpipe(int v) {
        fprintf(stderr, "SIGPIPE!!\n");
        exit(0);
}
 
int     setup_listener(const int port) {
        int     skt;
        struct  sockaddr_in     my_addr;
 
        printf("Listening on port %d\n", port);
 
        skt = socket(AF_INET, SOCK_STREAM, 0);
        if (skt < 0) {
                perror("Could not allocate socket: ");
                exit(-1);
        }
 
        // Set the reuse address option
        {
                int optv = 1, er;
                er = setsockopt(skt, SOL_SOCKET, SO_REUSEADDR, &optv, sizeof(optv));
                if (er != 0) {
                        perror("SockOpt Err:");
                        exit(-1);
                }
        }
 
        memset(&my_addr, 0, sizeof(struct sockaddr_in)); // clear structure
        my_addr.sin_family = AF_INET;
        my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
        my_addr.sin_port = htons(port);
 
        if (bind(skt, (struct sockaddr *)&my_addr, sizeof(my_addr))!=0) {
                perror("BIND FAILED:");
                exit(-1);
        }
 
        if (listen(skt, 1) != 0) {
                perror("Listen failed:");
                exit(-1);
        }
 
        return skt;
}
 
class   LINBUFS {
public:
        char    m_iline[512], m_oline[512];
        char    m_buf[256];
        int     m_ilen, m_olen;
        bool    m_connected;
 
        LINBUFS(void) {
                m_ilen = 0; m_olen = 0; m_connected = false;
        }
};
 
bool    check_incoming(LINBUFS &lb, USBI *usbp, int confd, int timeout) {
        struct  pollfd  p[2];
        int     pv, nfds;
 
        if (confd >= 0) {
                // Only do this if we currently have a network connection
                p[0].fd = confd;
                p[0].events = POLLIN | POLLRDHUP | POLLERR;
                nfds = 1;
 
                if ((pv=poll(p, nfds, timeout)) < 0) {
                        perror("Poll Failed!  O/S Err:");
                        exit(-1);
                }
                if (p[0].revents & POLLIN) {
                        /*
                         else if (p[0].revents)
                        printf("UNKNOWN TTY EVENT: %d\n", p[0].revents);
                */
                        int nr = read(confd, lb.m_buf, 256);
                        if (nr == 0) {
                                lb.m_connected = false;
                                if (lb.m_olen > 0) {
                                        lb.m_oline[lb.m_olen] = '\0';
                                        printf("< %s\n", lb.m_oline);
                                } lb.m_olen = 0;
                                close(confd);
                        } else if (nr > 0) {
                                usbp->write(lb.m_buf, nr);
                        } for(int i=0; i<nr; i++) {
                                lb.m_oline[lb.m_olen++] = lb.m_buf[i];
                                assert(lb.m_buf[i] != '\0');
                                if ((lb.m_oline[lb.m_olen-1]=='\n')
                                        ||(lb.m_oline[lb.m_olen-1]=='\r')
                                        ||(lb.m_olen >= (int)sizeof(lb.m_oline)-1)) {
                                        if (lb.m_olen >= (int)sizeof(lb.m_oline)-1)
                                                lb.m_oline[lb.m_olen] = '\0';
                                        else
                                                lb.m_oline[lb.m_olen-1] = '\0';
                                        if (lb.m_olen > 1)
                                                printf("< %s\n", lb.m_oline);
                                        lb.m_olen = 0;
                                }
                        }
                } else if ((nfds>1)&&(p[1].revents)) {
                        printf("UNKNOWN SKT EVENT: %d\n", p[1].revents);
                }
        }
 
        if (usbp->poll(2)) {
                int     nr, nrn;
 
                nr = nrn = usbp->read(lb.m_buf,1,2);
                while((nrn>0)&&(nr<255)&&((lb.m_buf[0]&0x80)==0)&&(lb.m_buf[0]>0x10)) {
                        nrn = usbp->read(&lb.m_buf[nr],1,2);
                        nr += nrn;
                } if ((nr > 0)&&(confd >= 0)) {
                        // Return our result if we have a network
                        // connection
                        write(confd, lb.m_buf, nr);
                } for(int i=0; i<nr; i++) {
                        lb.m_iline[lb.m_ilen++] = lb.m_buf[i];
                        if ((lb.m_iline[lb.m_ilen-1]=='\n')
                                ||(lb.m_iline[lb.m_ilen-1]=='\r')
                                ||(lb.m_ilen >= (int)sizeof(lb.m_iline)-1)) {
                                if (lb.m_ilen >= (int)sizeof(lb.m_iline)-1)
                                        lb.m_iline[lb.m_ilen] = '\0';
                                else
                                        lb.m_iline[lb.m_ilen-1] = '\0';
                                if (lb.m_ilen > 1)
                                        printf("%c %s\n",
                                                (confd>=0)?'>':'#', lb.m_iline);
                                lb.m_ilen = 0;
                        }
                }
        }
 
        return (pv > 0);
}
 
int     myaccept(int skt, int timeout) {
        int     con = -1;
        struct  pollfd  p[1];
        int     pv;
 
        p[0].fd = skt;
        p[0].events = POLLIN | POLLERR;
        if ((pv=poll(p, 1, timeout)) < 0) {
                perror("Poll Failed!  O/S Err:");
                exit(-1);
        } if (p[0].revents & POLLIN) {
                con = accept(skt, 0, 0);
                if (con < 0) {
                        perror("Accept failed!  O/S Err:");
                        exit(-1);
                }
        } return con;
}
 
int     main(int argc, char **argv) {
        // First, accept a network connection
        int     skt = setup_listener(FPGAPORT);
        USBI    *usbp;
        bool    done = false;
 
        signal(SIGSTOP, sigstop);
        signal(SIGBUS, sigbus);
        signal(SIGSEGV, sigsegv);
        signal(SIGPIPE, SIG_IGN);
        signal(SIGINT, sigint);
        signal(SIGHUP, sighup);
 
        usbp = new USBI();
 
        LINBUFS lb;
        while(!done) {
                int     con;
 
                // Accept a connection before going on
                // Let's call poll(), so we can still read any
                // tty messages even when not accepted
                con = myaccept(skt, 50);
                if (con >= 0) {
                        lb.m_connected = true;
 
                        /*
                        // Set our new socket as non-blocking
                        int flags = fcntl(fd, F_GETFL, 0);
                        flags |= O_NONBLOCK;
                        fcntl(fd, F_SETFL, flags);
                        */
 
                        // printf("Received a new connection\n");
                }
 
                // Flush any buffer within the TTY
                while(check_incoming(lb, usbp, -1, 0))
                        ;
 
                // Now, process that connection until it's gone
                while(lb.m_connected) {
                        check_incoming(lb, usbp, con, -1);
                }
        }
 
        printf("Closing our socket\n");
        close(skt);
}
 

Browse

Tools

Subversion Repositories xulalx25soc

[/] [xulalx25soc/] [trunk/] [sw/] [netusb.cpp] - Blame information for rev 84

Line No.	Rev	Author	Line
1	5	dgisselq	`////////////////////////////////////////////////////////////////////////////////`
2			`//`
3			`// Filename: netusb.cpp`
4			`//`
5			`// Project: XuLA2 board`
6			`//`
7			`// Purpose: Forwards a XuLA2 board USB connection over a TCP socket, so`
8			`// a non-local computer can control the board.`
9			`//`
10			`//`
11			`// Creator: Dan Gisselquist, Ph.D.`
12			`// Gisselquist Technology, LLC`
13			`//`
14			`////////////////////////////////////////////////////////////////////////////////`
15			`//`
16			`// Copyright (C) 2015, Gisselquist Technology, LLC`
17			`//`
18			`// This program is free software (firmware): you can redistribute it and/or`
19			`// modify it under the terms of the GNU General Public License as published`
20			`// by the Free Software Foundation, either version 3 of the License, or (at`
21			`// your option) any later version.`
22			`//`
23			`// This program is distributed in the hope that it will be useful, but WITHOUT`
24			`// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or`
25			`// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License`
26			`// for more details.`
27			`//`
28			`// License: GPL, v3, as defined and found on www.gnu.org,`
29			`// http://www.gnu.org/licenses/gpl.html`
30			`//`
31			`//`
32			`////////////////////////////////////////////////////////////////////////////////`
33			`//`
34			`//`
35			`#include <stdio.h>`
36			`#include <stdlib.h>`
37			`#include <unistd.h>`
38			`#include <sys/types.h>`
39			`#include <sys/stat.h>`
40			`#include <fcntl.h>`
41			`#include <termios.h>`
42			`#include <sys/socket.h>`
43			`#include <arpa/inet.h>`
44			`#include <string.h>`
45			`#include <poll.h>`
46			`#include <signal.h>`
47			`#include <ctype.h>`
48			`#include <assert.h>`
49			`#include <errno.h>`
50
51			`#include "port.h"`
52			`#include "usbi.h"`
53
54			`void sigstop(int v) {`
55			`fprintf(stderr, "SIGSTOP!!\n");`
56			`exit(0);`
57			`}`
58			`void sighup(int v) {`
59			`fprintf(stderr, "SIGHUP!!\n");`
60			`exit(0);`
61			`}`
62			`void sigint(int v) {`
63			`fprintf(stderr, "SIGINT!!\n");`
64			`exit(0);`
65			`}`
66			`void sigsegv(int v) {`
67			`fprintf(stderr, "SIGSEGV!!\n");`
68			`exit(0);`
69			`}`
70			`void sigbus(int v) {`
71			`fprintf(stderr, "SIGBUS!!\n");`
72			`exit(0);`
73			`}`
74			`void sigpipe(int v) {`
75			`fprintf(stderr, "SIGPIPE!!\n");`
76			`exit(0);`
77			`}`
78
79			`int setup_listener(const int port) {`
80			`int skt;`
81			`struct sockaddr_in my_addr;`
82
83			`printf("Listening on port %d\n", port);`
84
85			`skt = socket(AF_INET, SOCK_STREAM, 0);`
86			`if (skt < 0) {`
87			`perror("Could not allocate socket: ");`
88			`exit(-1);`
89			`}`
90
91			`// Set the reuse address option`
92			`{`
93			`int optv = 1, er;`
94			`er = setsockopt(skt, SOL_SOCKET, SO_REUSEADDR, &optv, sizeof(optv));`
95			`if (er != 0) {`
96			`perror("SockOpt Err:");`
97			`exit(-1);`
98			`}`
99			`}`
100
101			`memset(&my_addr, 0, sizeof(struct sockaddr_in)); // clear structure`
102			`my_addr.sin_family = AF_INET;`
103			`my_addr.sin_addr.s_addr = htonl(INADDR_ANY);`
104			`my_addr.sin_port = htons(port);`
105
106			`if (bind(skt, (struct sockaddr *)&my_addr, sizeof(my_addr))!=0) {`
107			`perror("BIND FAILED:");`
108			`exit(-1);`
109			`}`
110
111			`if (listen(skt, 1) != 0) {`
112			`perror("Listen failed:");`
113			`exit(-1);`
114			`}`
115
116			`return skt;`
117			`}`
118
119			`class LINBUFS {`
120			`public:`
121			`char m_iline[512], m_oline[512];`
122			`char m_buf[256];`
123			`int m_ilen, m_olen;`
124			`bool m_connected;`
125
126			`LINBUFS(void) {`
127			`m_ilen = 0; m_olen = 0; m_connected = false;`
128			`}`
129			`};`
130
131			`bool check_incoming(LINBUFS &lb, USBI *usbp, int confd, int timeout) {`
132			`struct pollfd p[2];`
133			`int pv, nfds;`
134
135			`if (confd >= 0) {`
136			`// Only do this if we currently have a network connection`
137			`p[0].fd = confd;`
138			`p[0].events = POLLIN \| POLLRDHUP \| POLLERR;`
139			`nfds = 1;`
140
141			`if ((pv=poll(p, nfds, timeout)) < 0) {`
142			`perror("Poll Failed! O/S Err:");`
143			`exit(-1);`
144			`}`
145			`if (p[0].revents & POLLIN) {`
146			`/*`
147			`else if (p[0].revents)`
148			`printf("UNKNOWN TTY EVENT: %d\n", p[0].revents);`
149			`*/`
150			`int nr = read(confd, lb.m_buf, 256);`
151			`if (nr == 0) {`
152			`lb.m_connected = false;`
153			`if (lb.m_olen > 0) {`
154			`lb.m_oline[lb.m_olen] = '\0';`
155			`printf("< %s\n", lb.m_oline);`
156			`} lb.m_olen = 0;`
157			`close(confd);`
158			`} else if (nr > 0) {`
159			`usbp->write(lb.m_buf, nr);`
160			`} for(int i=0; i<nr; i++) {`
161			`lb.m_oline[lb.m_olen++] = lb.m_buf[i];`
162			`assert(lb.m_buf[i] != '\0');`
163	25	dgisselq	`if ((lb.m_oline[lb.m_olen-1]=='\n')`
164			`\|\|(lb.m_oline[lb.m_olen-1]=='\r')`
165			`\|\|(lb.m_olen >= (int)sizeof(lb.m_oline)-1)) {`
166	5	dgisselq	`if (lb.m_olen >= (int)sizeof(lb.m_oline)-1)`
167			`lb.m_oline[lb.m_olen] = '\0';`
168			`else`
169			`lb.m_oline[lb.m_olen-1] = '\0';`
170			`if (lb.m_olen > 1)`
171			`printf("< %s\n", lb.m_oline);`
172			`lb.m_olen = 0;`
173			`}`
174			`}`
175			`} else if ((nfds>1)&&(p[1].revents)) {`
176			`printf("UNKNOWN SKT EVENT: %d\n", p[1].revents);`
177			`}`
178			`}`
179
180			`if (usbp->poll(2)) {`
181			`int nr, nrn;`
182
183			`nr = nrn = usbp->read(lb.m_buf,1,2);`
184			`while((nrn>0)&&(nr<255)&&((lb.m_buf[0]&0x80)==0)&&(lb.m_buf[0]>0x10)) {`
185			`nrn = usbp->read(&lb.m_buf[nr],1,2);`
186			`nr += nrn;`
187			`} if ((nr > 0)&&(confd >= 0)) {`
188			`// Return our result if we have a network`
189			`// connection`
190			`write(confd, lb.m_buf, nr);`
191			`} for(int i=0; i<nr; i++) {`
192			`lb.m_iline[lb.m_ilen++] = lb.m_buf[i];`
193	25	dgisselq	`if ((lb.m_iline[lb.m_ilen-1]=='\n')`
194			`\|\|(lb.m_iline[lb.m_ilen-1]=='\r')`
195			`\|\|(lb.m_ilen >= (int)sizeof(lb.m_iline)-1)) {`
196			`if (lb.m_ilen >= (int)sizeof(lb.m_iline)-1)`
197	5	dgisselq	`lb.m_iline[lb.m_ilen] = '\0';`
198			`else`
199			`lb.m_iline[lb.m_ilen-1] = '\0';`
200			`if (lb.m_ilen > 1)`
201			`printf("%c %s\n",`
202			`(confd>=0)?'>':'#', lb.m_iline);`
203			`lb.m_ilen = 0;`
204			`}`
205			`}`
206			`}`
207
208			`return (pv > 0);`
209			`}`
210
211			`int myaccept(int skt, int timeout) {`
212			`int con = -1;`
213			`struct pollfd p[1];`
214			`int pv;`
215
216			`p[0].fd = skt;`
217			`p[0].events = POLLIN \| POLLERR;`
218			`if ((pv=poll(p, 1, timeout)) < 0) {`
219			`perror("Poll Failed! O/S Err:");`
220			`exit(-1);`
221			`} if (p[0].revents & POLLIN) {`
222			`con = accept(skt, 0, 0);`
223			`if (con < 0) {`
224			`perror("Accept failed! O/S Err:");`
225			`exit(-1);`
226			`}`
227			`} return con;`
228			`}`
229
230			`int main(int argc, char **argv) {`
231			`// First, accept a network connection`
232			`int skt = setup_listener(FPGAPORT);`
233			`USBI *usbp;`
234			`bool done = false;`
235
236			`signal(SIGSTOP, sigstop);`
237			`signal(SIGBUS, sigbus);`
238			`signal(SIGSEGV, sigsegv);`
239			`signal(SIGPIPE, SIG_IGN);`
240			`signal(SIGINT, sigint);`
241			`signal(SIGHUP, sighup);`
242
243			`usbp = new USBI();`
244
245			`LINBUFS lb;`
246			`while(!done) {`
247			`int con;`
248
249			`// Accept a connection before going on`
250			`// Let's call poll(), so we can still read any`
251			`// tty messages even when not accepted`
252			`con = myaccept(skt, 50);`
253			`if (con >= 0) {`
254			`lb.m_connected = true;`
255
256			`/*`
257			`// Set our new socket as non-blocking`
258			`int flags = fcntl(fd, F_GETFL, 0);`
259			`flags \|= O_NONBLOCK;`
260			`fcntl(fd, F_SETFL, flags);`
261			`*/`
262
263			`// printf("Received a new connection\n");`
264			`}`
265
266			`// Flush any buffer within the TTY`
267			`while(check_incoming(lb, usbp, -1, 0))`
268			`;`
269
270			`// Now, process that connection until it's gone`
271			`while(lb.m_connected) {`
272			`check_incoming(lb, usbp, con, -1);`
273			`}`
274			`}`
275
276			`printf("Closing our socket\n");`
277			`close(skt);`
278			`}`
279