examples: fix linking with json-c
[project/libubox.git] / examples / ustream-example.c
1 #include <sys/socket.h>
2 #include <netinet/in.h>
3
4 #include <stdio.h>
5 #include <getopt.h>
6 #include <stdlib.h>
7 #include <string.h>
8
9 #include "ustream.h"
10 #include "uloop.h"
11 #include "usock.h"
12
13 static struct uloop_fd server;
14 static const char *port = "10000";
15 struct client *next_client = NULL;
16
17 struct client {
18         struct sockaddr_in sin;
19
20         struct ustream_fd s;
21         int ctr;
22 };
23
24 static void client_read_cb(struct ustream *s, int bytes)
25 {
26         struct client *cl = container_of(s, struct client, s.stream);
27         struct ustream_buf *buf = s->r.head;
28         char *newline, *str;
29
30         do {
31                 str = ustream_get_read_buf(s, NULL);
32                 if (!str)
33                         break;
34
35                 newline = strchr(buf->data, '\n');
36                 if (!newline)
37                         break;
38
39                 *newline = 0;
40                 ustream_printf(s, "%s\n", str);
41                 ustream_consume(s, newline + 1 - str);
42                 cl->ctr += newline + 1 - str;
43         } while(1);
44
45         if (s->w.data_bytes > 256 && !ustream_read_blocked(s)) {
46                 fprintf(stderr, "Block read, bytes: %d\n", s->w.data_bytes);
47                 ustream_set_read_blocked(s, true);
48         }
49 }
50
51 static void client_close(struct ustream *s)
52 {
53         struct client *cl = container_of(s, struct client, s.stream);
54
55         fprintf(stderr, "Connection closed\n");
56         ustream_free(s);
57         close(cl->s.fd.fd);
58         free(cl);
59 }
60
61 static void client_notify_write(struct ustream *s, int bytes)
62 {
63         fprintf(stderr, "Wrote %d bytes, pending: %d\n", bytes, s->w.data_bytes);
64
65         if (s->w.data_bytes < 128 && ustream_read_blocked(s)) {
66                 fprintf(stderr, "Unblock read\n");
67                 ustream_set_read_blocked(s, false);
68         }
69 }
70
71 static void client_notify_state(struct ustream *s)
72 {
73         struct client *cl = container_of(s, struct client, s.stream);
74
75         if (!s->eof)
76                 return;
77
78         fprintf(stderr, "eof!, pending: %d, total: %d\n", s->w.data_bytes, cl->ctr);
79         if (!s->w.data_bytes)
80                 return client_close(s);
81
82 }
83
84 static void server_cb(struct uloop_fd *fd, unsigned int events)
85 {
86         struct client *cl;
87         unsigned int sl = sizeof(struct sockaddr_in);
88         int sfd;
89
90         if (!next_client)
91                 next_client = calloc(1, sizeof(*next_client));
92
93         cl = next_client;
94         sfd = accept(server.fd, (struct sockaddr *) &cl->sin, &sl);
95         if (sfd < 0) {
96                 fprintf(stderr, "Accept failed\n");
97                 return;
98         }
99
100         cl->s.stream.string_data = true;
101         cl->s.stream.notify_read = client_read_cb;
102         cl->s.stream.notify_state = client_notify_state;
103         cl->s.stream.notify_write = client_notify_write;
104         ustream_fd_init(&cl->s, sfd);
105         next_client = NULL;
106         fprintf(stderr, "New connection\n");
107 }
108
109 static int run_server(void)
110 {
111
112         server.cb = server_cb;
113         server.fd = usock(USOCK_TCP | USOCK_SERVER | USOCK_IPV4ONLY | USOCK_NUMERIC, "127.0.0.1", port);
114         if (server.fd < 0) {
115                 perror("usock");
116                 return 1;
117         }
118
119         uloop_init();
120         uloop_fd_add(&server, ULOOP_READ);
121         uloop_run();
122
123         return 0;
124 }
125
126 static int usage(const char *name)
127 {
128         fprintf(stderr, "Usage: %s -p <port>\n", name);
129         return 1;
130 }
131
132 int main(int argc, char **argv)
133 {
134         int ch;
135
136         while ((ch = getopt(argc, argv, "p:")) != -1) {
137                 switch(ch) {
138                 case 'p':
139                         port = optarg;
140                         break;
141                 default:
142                         return usage(argv[0]);
143                 }
144         }
145
146         return run_server();
147 }