1 | /*
|
---|
2 | * Copyright (c) 2001, Adam Dunkels.
|
---|
3 | * All rights reserved.
|
---|
4 | *
|
---|
5 | * Redistribution and use in source and binary forms, with or without
|
---|
6 | * modification, are permitted provided that the following conditions
|
---|
7 | * are met:
|
---|
8 | * 1. Redistributions of source code must retain the above copyright
|
---|
9 | * notice, this list of conditions and the following disclaimer.
|
---|
10 | * 2. Redistributions in binary form must reproduce the above copyright
|
---|
11 | * notice, this list of conditions and the following disclaimer in the
|
---|
12 | * documentation and/or other materials provided with the distribution.
|
---|
13 | * 3. All advertising materials mentioning features or use of this software
|
---|
14 | * must display the following acknowledgement:
|
---|
15 | * This product includes software developed by Adam Dunkels.
|
---|
16 | * 4. The name of the author may not be used to endorse or promote
|
---|
17 | * products derived from this software without specific prior
|
---|
18 | * written permission.
|
---|
19 | *
|
---|
20 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
|
---|
21 | * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
---|
22 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
---|
23 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
|
---|
24 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
---|
25 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
|
---|
26 | * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
---|
27 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
---|
28 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
---|
29 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
---|
30 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
---|
31 | *
|
---|
32 | * This file is part of the uIP TCP/IP stack.
|
---|
33 | *
|
---|
34 | * $Id: uip_task.c 158 2016-02-20 13:43:32Z coas-nagasima $
|
---|
35 | *
|
---|
36 | */
|
---|
37 |
|
---|
38 | #include <string.h>
|
---|
39 | #include <kernel.h>
|
---|
40 | #include "net/ip/uip.h"
|
---|
41 | #include "net/ipv4/uip_arp.h"
|
---|
42 | #include "sys/timer.h"
|
---|
43 | #include "uip_task.h"
|
---|
44 | #include "uip_nic_config.h"
|
---|
45 | #include "kernel_cfg.h"
|
---|
46 | #include "uip_adpt.h"
|
---|
47 | #include "uip_app_config.h"
|
---|
48 | #include "sil.h"
|
---|
49 |
|
---|
50 | #ifndef NULL
|
---|
51 | #define NULL (void *)0
|
---|
52 | #endif /* NULL */
|
---|
53 |
|
---|
54 | struct uip_task_t {
|
---|
55 | ID tskid;
|
---|
56 | struct pt pt;
|
---|
57 | struct uip_timer periodic_timer, arp_timer;
|
---|
58 | clock_time_t timer;
|
---|
59 | uint8_t uip_buf[UIP_BUFSIZE + 2];
|
---|
60 | };
|
---|
61 |
|
---|
62 | struct uip_task_t uiptsk = {
|
---|
63 | UIP_TASK
|
---|
64 | };
|
---|
65 |
|
---|
66 | uint8_t *uip_buf = uiptsk.uip_buf;
|
---|
67 |
|
---|
68 | typedef struct _uip_out_buf_t
|
---|
69 | {
|
---|
70 | union {
|
---|
71 | struct uip_conn *tcp;
|
---|
72 | struct uip_udp_conn *udp;
|
---|
73 | } cepid;
|
---|
74 | uip_ipaddr_t ripaddr;
|
---|
75 | uint16_t rport;
|
---|
76 | int len;
|
---|
77 | uint8_t data[UIP_BUFSIZE + 2];
|
---|
78 | } UIP_OUT_BUF_T;
|
---|
79 |
|
---|
80 | #define UIP_BUF_COUNT 6
|
---|
81 | UIP_OUT_BUF_T uip_out_buf[UIP_BUF_COUNT];
|
---|
82 | int uip_out_wpos = 0;
|
---|
83 | int uip_out_rpos = 0;
|
---|
84 | uint8_t my_ip[4] = { IPV4_ADDR_LOCAL };
|
---|
85 | uint8_t my_netmask[4] = { IPV4_ADDR_LOCAL_MASK };
|
---|
86 | uint8_t my_default_router[4] = { IPV4_ADDR_DEFAULT_GW };
|
---|
87 | int ws_out_req;
|
---|
88 | int ws_out_res;
|
---|
89 | #ifdef __DHCPC_H__
|
---|
90 | struct dhcpc_state *dhcpc;
|
---|
91 | extern bool_t dhcp_enable;
|
---|
92 | #endif
|
---|
93 |
|
---|
94 | /*---------------------------------------------------------------------------*/
|
---|
95 | static
|
---|
96 | PT_THREAD(uip_task_pt(struct uip_task_t *uiptsk))
|
---|
97 | {
|
---|
98 | T_IF_SOFTC *ic = IF_ETHER_NIC_GET_SOFTC();
|
---|
99 | int ret;
|
---|
100 | bool_t tx;
|
---|
101 |
|
---|
102 | PT_BEGIN(&uiptsk->pt);
|
---|
103 |
|
---|
104 | /* NIC を初期化する。*/
|
---|
105 | IF_ETHER_NIC_PROBE(ic);
|
---|
106 | IF_ETHER_NIC_INIT(ic);
|
---|
107 |
|
---|
108 | uip_sethostaddr(my_ip);
|
---|
109 | uip_setnetmask(my_netmask);
|
---|
110 | uip_setdraddr(my_default_router);
|
---|
111 |
|
---|
112 | timer_set(&uiptsk->periodic_timer, CLOCK_SECOND / 2);
|
---|
113 | timer_set(&uiptsk->arp_timer, CLOCK_SECOND * 10);
|
---|
114 |
|
---|
115 | uip_init();
|
---|
116 | #ifdef __DHCPC_H__
|
---|
117 | if(dhcp_enable){
|
---|
118 | dhcpc = dhcpc_init(uip_ethaddr.addr, sizeof(uip_ethaddr.addr));
|
---|
119 | }
|
---|
120 | #endif
|
---|
121 | uip_task_init((intptr_t)uiptsk);
|
---|
122 |
|
---|
123 | for (;;) {
|
---|
124 | sil_wrb_mem((uint8_t *)0x0008C02A, sil_reb_mem((uint8_t *)0x0008C02A) & ~0x03);
|
---|
125 |
|
---|
126 | PT_WAIT_UNTIL(&uiptsk->pt, (ret = ic->link_pre != ic->link_now ? 1 :
|
---|
127 | (uip_out_buf[uip_out_rpos].len > 0 ? 3 :
|
---|
128 | (ws_out_req != ws_out_res ? 4 :
|
---|
129 | (timer_expired(&uiptsk->periodic_timer) ? 5 :
|
---|
130 | (ic->rxb_read != ic->rxb_write ? 2 : 0))))) != 0);
|
---|
131 |
|
---|
132 | if(ret == 1){
|
---|
133 | sil_wrb_mem((uint8_t *)0x0008C02A, sil_reb_mem((uint8_t *)0x0008C02A) | 0x01);
|
---|
134 | if(IF_ETHER_NIC_LINK(ic)){
|
---|
135 | bool_t cng = ic->link_pre != ic->link_now;
|
---|
136 | ic->link_pre = ic->link_now;
|
---|
137 | if(cng && ic->link_pre){
|
---|
138 | #ifdef __DHCPC_H__
|
---|
139 | if(dhcp_enable){
|
---|
140 | sil_wrb_mem((uint8_t *)0x0008C02A, sil_reb_mem((uint8_t *)0x0008C02A) | 0x04);
|
---|
141 | uip_buf = uiptsk->uip_buf;
|
---|
142 | uip_len = 0;
|
---|
143 | dhcpc_request(dhcpc);
|
---|
144 | /* If the above function invocation resulted in data that
|
---|
145 | should be sent out on the network, the global variable
|
---|
146 | uip_len is set to a value > 0. */
|
---|
147 | if (uip_len > 0) {
|
---|
148 | uip_arp_out();
|
---|
149 | for (;;) {
|
---|
150 | tx = IF_ETHER_NIC_START(ic, uip_buf, uip_len);
|
---|
151 | if (tx)
|
---|
152 | break;
|
---|
153 | PT_YIELD(&uiptsk->pt);
|
---|
154 | }
|
---|
155 | }
|
---|
156 | }
|
---|
157 | else{
|
---|
158 | DHCP4_CLI_SET_ADDR_CALLBACK();
|
---|
159 | }
|
---|
160 | #else
|
---|
161 | DHCP4_CLI_SET_ADDR_CALLBACK();
|
---|
162 | #endif
|
---|
163 | }
|
---|
164 | }
|
---|
165 | PT_YIELD(&uiptsk->pt);
|
---|
166 | continue;
|
---|
167 | }
|
---|
168 | else if (ret == 2) {
|
---|
169 | sil_wrb_mem((uint8_t *)0x0008C02A, sil_reb_mem((uint8_t *)0x0008C02A) | 0x02);
|
---|
170 | ic->rxb_read++;
|
---|
171 | uip_buf = uiptsk->uip_buf;
|
---|
172 | uip_len = IF_ETHER_NIC_READ(ic, (void **)&uip_buf);
|
---|
173 | if ((uip_len > 0) && (uip_buf != NULL)){
|
---|
174 | if (((struct uip_eth_hdr *)uip_buf)->type == htons(UIP_ETHTYPE_IP)) {
|
---|
175 | uip_arp_ipin();
|
---|
176 | uip_input();
|
---|
177 | /* If the above function invocation resulted in data that
|
---|
178 | should be sent out on the network, the global variable
|
---|
179 | uip_len is set to a value > 0. */
|
---|
180 | if (uip_len > 0) {
|
---|
181 | uip_arp_out();
|
---|
182 | for (;;) {
|
---|
183 | tx = IF_ETHER_NIC_START(ic, uip_buf, uip_len);
|
---|
184 | if (tx)
|
---|
185 | break;
|
---|
186 | PT_YIELD(&uiptsk->pt);
|
---|
187 | }
|
---|
188 | PT_YIELD(&uiptsk->pt);
|
---|
189 | continue;
|
---|
190 | }
|
---|
191 | }
|
---|
192 | else if (((struct uip_eth_hdr *)uip_buf)->type == htons(UIP_ETHTYPE_ARP)) {
|
---|
193 | uip_arp_arpin();
|
---|
194 | /* If the above function invocation resulted in data that
|
---|
195 | should be sent out on the network, the global variable
|
---|
196 | uip_len is set to a value > 0. */
|
---|
197 | if (uip_len > 0) {
|
---|
198 | for (;;) {
|
---|
199 | tx = IF_ETHER_NIC_START(ic, uip_buf, uip_len);
|
---|
200 | if (tx)
|
---|
201 | break;
|
---|
202 | PT_YIELD(&uiptsk->pt);
|
---|
203 | }
|
---|
204 | PT_YIELD(&uiptsk->pt);
|
---|
205 | continue;
|
---|
206 | }
|
---|
207 | }
|
---|
208 | }
|
---|
209 | }
|
---|
210 | #if UIP_UDP
|
---|
211 | else if (ret == 3) {
|
---|
212 | UIP_OUT_BUF_T *buf = &uip_out_buf[uip_out_rpos];
|
---|
213 | struct uip_udp_conn *cepid = buf->cepid.udp;
|
---|
214 |
|
---|
215 | sil_wrb_mem((uint8_t *)0x0008C02A, sil_reb_mem((uint8_t *)0x0008C02A) | 0x02);
|
---|
216 |
|
---|
217 | uip_ipaddr_copy(cepid->ripaddr, buf->ripaddr);
|
---|
218 | cepid->rport = buf->rport;
|
---|
219 | uip_buf = buf->data;
|
---|
220 | uip_udp_send(buf->len);
|
---|
221 |
|
---|
222 | uip_udp_conn = cepid;
|
---|
223 | uip_process(UIP_UDP_SEND_CONN);
|
---|
224 | uip_ipaddr(cepid->ripaddr, 0, 0, 0, 0);
|
---|
225 | cepid->rport = 0;
|
---|
226 | uip_arp_out();
|
---|
227 | for (;;) {
|
---|
228 | tx = IF_ETHER_NIC_START(ic, uip_buf, uip_len);
|
---|
229 | if (tx)
|
---|
230 | break;
|
---|
231 | PT_YIELD(&uiptsk->pt);
|
---|
232 | }
|
---|
233 |
|
---|
234 | buf = &uip_out_buf[uip_out_rpos];
|
---|
235 | uip_out_rpos++;
|
---|
236 | if (uip_out_rpos >= UIP_BUF_COUNT)
|
---|
237 | uip_out_rpos = 0;
|
---|
238 | buf->len = 0;
|
---|
239 |
|
---|
240 | PT_YIELD(&uiptsk->pt);
|
---|
241 | continue;
|
---|
242 | }
|
---|
243 | #endif /* UIP_UDP */
|
---|
244 | else if (ret == 4) {
|
---|
245 | sil_wrb_mem((uint8_t *)0x0008C02A, sil_reb_mem((uint8_t *)0x0008C02A) | 0x02);
|
---|
246 | ws_out_res++;
|
---|
247 | for (ic->udp_pos = 0; ic->udp_pos < UIP_CONNS; ic->udp_pos++) {
|
---|
248 | uip_buf = uiptsk->uip_buf;
|
---|
249 | uip_len = 0;
|
---|
250 | uip_poll_conn(&uip_conns[ic->udp_pos]);
|
---|
251 | /* If the above function invocation resulted in data that
|
---|
252 | should be sent out on the network, the global variable
|
---|
253 | uip_len is set to a value > 0. */
|
---|
254 | if (uip_len > 0) {
|
---|
255 | uip_arp_out();
|
---|
256 | for (;;) {
|
---|
257 | tx = IF_ETHER_NIC_START(ic, uip_buf, uip_len);
|
---|
258 | if (tx)
|
---|
259 | break;
|
---|
260 | PT_YIELD(&uiptsk->pt);
|
---|
261 | }
|
---|
262 | PT_YIELD(&uiptsk->pt);
|
---|
263 | }
|
---|
264 | }
|
---|
265 | }
|
---|
266 | else if (ret == 5) {
|
---|
267 | timer_reset(&uiptsk->periodic_timer);
|
---|
268 | for (ic->udp_pos = 0; ic->udp_pos < UIP_CONNS; ic->udp_pos++) {
|
---|
269 | uip_buf = uiptsk->uip_buf;
|
---|
270 | uip_len = 0;
|
---|
271 | uip_periodic(ic->udp_pos);
|
---|
272 | /* If the above function invocation resulted in data that
|
---|
273 | should be sent out on the network, the global variable
|
---|
274 | uip_len is set to a value > 0. */
|
---|
275 | if (uip_len > 0) {
|
---|
276 | uip_arp_out();
|
---|
277 | for (;;) {
|
---|
278 | tx = IF_ETHER_NIC_START(ic, uip_buf, uip_len);
|
---|
279 | if (tx)
|
---|
280 | break;
|
---|
281 | PT_YIELD(&uiptsk->pt);
|
---|
282 | }
|
---|
283 | PT_YIELD(&uiptsk->pt);
|
---|
284 | }
|
---|
285 | }
|
---|
286 | #if UIP_UDP
|
---|
287 | for (ic->udp_pos = 0; ic->udp_pos < UIP_UDP_CONNS; ic->udp_pos++) {
|
---|
288 | uip_buf = uiptsk->uip_buf;
|
---|
289 | uip_len = 0;
|
---|
290 | uip_udp_periodic(ic->udp_pos);
|
---|
291 | /* If the above function invocation resulted in data that
|
---|
292 | should be sent out on the network, the global variable
|
---|
293 | uip_len is set to a value > 0. */
|
---|
294 | if (uip_len > 0) {
|
---|
295 | uip_arp_out();
|
---|
296 | for (;;) {
|
---|
297 | tx = IF_ETHER_NIC_START(ic, uip_buf, uip_len);
|
---|
298 | if (tx)
|
---|
299 | break;
|
---|
300 | PT_YIELD(&uiptsk->pt);
|
---|
301 | }
|
---|
302 | PT_YIELD(&uiptsk->pt);
|
---|
303 | }
|
---|
304 | }
|
---|
305 | #endif /* UIP_UDP */
|
---|
306 |
|
---|
307 | /* Call the ARP timer function every 10 seconds. */
|
---|
308 | if (timer_expired(&uiptsk->arp_timer)) {
|
---|
309 | timer_reset(&uiptsk->arp_timer);
|
---|
310 | uip_buf = uiptsk->uip_buf;
|
---|
311 | uip_len = 0;
|
---|
312 | uip_arp_timer();
|
---|
313 | }
|
---|
314 | }
|
---|
315 | }
|
---|
316 |
|
---|
317 | PT_END(&uiptsk->pt);
|
---|
318 | }
|
---|
319 |
|
---|
320 | /*
|
---|
321 | * uIP プロトスレッド起動タスク
|
---|
322 | */
|
---|
323 | void uip_task(intptr_t exinf)
|
---|
324 | {
|
---|
325 | struct uip_task_t *uiptsk = (struct uip_task_t *)exinf;
|
---|
326 |
|
---|
327 | uip_task_pt(uiptsk);
|
---|
328 | }
|
---|
329 |
|
---|
330 | /*
|
---|
331 | * uIP タスク起動用周期ハンドラー
|
---|
332 | */
|
---|
333 | void uip_cychdr(intptr_t exinf)
|
---|
334 | {
|
---|
335 | struct uip_task_t *uiptsk = (struct uip_task_t *)exinf;
|
---|
336 | uiptsk->timer++;
|
---|
337 | #ifndef UIP_ACT_TSK_ONLY_ON_SEND
|
---|
338 | if(timer_expired(&uiptsk->periodic_timer))
|
---|
339 | (void)iact_tsk(uiptsk->tskid);
|
---|
340 | #endif
|
---|
341 | }
|
---|
342 |
|
---|
343 | struct uip_conn *
|
---|
344 | tcp_acre_cep(const T_TCP_CCEP *pk_ccep)
|
---|
345 | {
|
---|
346 | struct uip_conn *cepid;
|
---|
347 |
|
---|
348 | cepid = uip_connect((uip_ipaddr_t *)&pk_ccep->ripaddr, htons(pk_ccep->rport));
|
---|
349 | if (cepid != NULL) {
|
---|
350 | //cepid->appstate.tcp_callback = pk_ccep->callback;
|
---|
351 | }
|
---|
352 |
|
---|
353 | return cepid;
|
---|
354 | }
|
---|
355 |
|
---|
356 | int
|
---|
357 | tcp_snd_dat(struct uip_conn *cepid, T_IPV4EP *p_dstaddr, void *data, int len)
|
---|
358 | {
|
---|
359 | UIP_OUT_BUF_T *buf = &uip_out_buf[uip_out_wpos];
|
---|
360 |
|
---|
361 | if (buf->len == 0) {
|
---|
362 | buf->cepid.tcp = cepid;
|
---|
363 | uip_ipaddr_copy(buf->ripaddr, p_dstaddr->ipaddr);
|
---|
364 | buf->rport = htons(p_dstaddr->portno);
|
---|
365 | memcpy(&buf->data[UIP_IPTCPH_LEN + UIP_LLH_LEN], data, len);
|
---|
366 | uip_out_buf[uip_out_wpos].len = len;
|
---|
367 | uip_out_wpos++;
|
---|
368 | if (uip_out_wpos >= UIP_BUF_COUNT)
|
---|
369 | uip_out_wpos = 0;
|
---|
370 | #ifndef UIP_ACT_TSK_ONLY_ON_SEND
|
---|
371 | act_tsk(UIP_TASK);
|
---|
372 | #endif
|
---|
373 | return len;
|
---|
374 | }
|
---|
375 |
|
---|
376 | return 0;
|
---|
377 | }
|
---|
378 |
|
---|
379 | int
|
---|
380 | tcp_rcv_dat(struct uip_conn *cepid, T_IPV4EP *p_srcaddr, void *data, int len)
|
---|
381 | {
|
---|
382 | int rlen;
|
---|
383 |
|
---|
384 | if (!uip_newdata())
|
---|
385 | return 0;
|
---|
386 |
|
---|
387 | rlen = uip_datalen();
|
---|
388 | if (rlen > len)
|
---|
389 | rlen = len;
|
---|
390 |
|
---|
391 | uip_ipaddr_copy(p_srcaddr->ipaddr, ((struct uip_tcpip_hdr *)&uip_buf[UIP_LLH_LEN])->srcipaddr);
|
---|
392 | p_srcaddr->portno = ntohs(((struct uip_tcpip_hdr *)&uip_buf[UIP_LLH_LEN])->srcport);
|
---|
393 | memcpy(data, uip_appdata, rlen);
|
---|
394 |
|
---|
395 | return rlen;
|
---|
396 | }
|
---|
397 |
|
---|
398 | void uip_appcall(void)
|
---|
399 | {
|
---|
400 | uip_tcp_appstate_t *s = &uip_conn->appstate;
|
---|
401 | //s->tcp_callback(uip_conn, 0, &s->parblk);
|
---|
402 | }
|
---|
403 | #if UIP_UDP
|
---|
404 | /*---------------------------------------------------------------------------*/
|
---|
405 | struct uip_udp_conn *
|
---|
406 | udp_acre_cep(const T_UDP_CCEP *pk_ccep)
|
---|
407 | {
|
---|
408 | struct uip_udp_conn *cepid;
|
---|
409 |
|
---|
410 | cepid = uip_udp_new((uip_ipaddr_t *)&pk_ccep->ripaddr, htons(pk_ccep->rport));
|
---|
411 | if (cepid != NULL) {
|
---|
412 | cepid->appstate.udp_callback = pk_ccep->callback;
|
---|
413 | uip_udp_bind(cepid, htons(pk_ccep->lport));
|
---|
414 | }
|
---|
415 |
|
---|
416 | return cepid;
|
---|
417 | }
|
---|
418 |
|
---|
419 | int
|
---|
420 | udp_snd_dat(struct uip_udp_conn *cepid, T_IPV4EP *p_dstaddr, void *data, int len)
|
---|
421 | {
|
---|
422 | UIP_OUT_BUF_T *buf = &uip_out_buf[uip_out_wpos];
|
---|
423 |
|
---|
424 | if (buf->len == 0) {
|
---|
425 | buf->cepid.udp = cepid;
|
---|
426 | uip_ipaddr_copy(buf->ripaddr, p_dstaddr->ipaddr);
|
---|
427 | buf->rport = htons(p_dstaddr->portno);
|
---|
428 | memcpy(&buf->data[UIP_IPUDPH_LEN + UIP_LLH_LEN], data, len);
|
---|
429 | uip_out_buf[uip_out_wpos].len = len;
|
---|
430 | uip_out_wpos++;
|
---|
431 | if (uip_out_wpos >= UIP_BUF_COUNT)
|
---|
432 | uip_out_wpos = 0;
|
---|
433 | #ifndef UIP_ACT_TSK_ONLY_ON_SEND
|
---|
434 | act_tsk(UIP_TASK);
|
---|
435 | #endif
|
---|
436 | return len;
|
---|
437 | }
|
---|
438 |
|
---|
439 | return 0;
|
---|
440 | }
|
---|
441 |
|
---|
442 | int
|
---|
443 | udp_rcv_dat(struct uip_udp_conn *cepid, T_IPV4EP *p_srcaddr, void *data, int len)
|
---|
444 | {
|
---|
445 | int rlen;
|
---|
446 |
|
---|
447 | if (!uip_newdata())
|
---|
448 | return 0;
|
---|
449 |
|
---|
450 | rlen = uip_datalen();
|
---|
451 | if (rlen > len)
|
---|
452 | rlen = len;
|
---|
453 |
|
---|
454 | uip_ipaddr_copy(p_srcaddr->ipaddr, ((struct uip_udpip_hdr *)&uip_buf[UIP_LLH_LEN])->srcipaddr);
|
---|
455 | p_srcaddr->portno = ntohs(((struct uip_udpip_hdr *)&uip_buf[UIP_LLH_LEN])->srcport);
|
---|
456 | memcpy(data, uip_appdata, rlen);
|
---|
457 |
|
---|
458 | return rlen;
|
---|
459 | }
|
---|
460 |
|
---|
461 | void uip_udp_appcall(void)
|
---|
462 | {
|
---|
463 | uip_udp_appstate_t *s = &uip_udp_conn->appstate;
|
---|
464 | s->udp_callback(uip_udp_conn, 0, &s->parblk);
|
---|
465 | }
|
---|
466 | #endif
|
---|
467 | /*---------------------------------------------------------------------------*/
|
---|
468 | void
|
---|
469 | uip_log(char *m)
|
---|
470 | {
|
---|
471 | printf("uIP log message: %s\n", m);
|
---|
472 | }
|
---|
473 | #ifdef __DHCPC_H__
|
---|
474 | void
|
---|
475 | dhcpc_configured(const struct dhcpc_state *s)
|
---|
476 | {
|
---|
477 | sil_wrb_mem((uint8_t *)0x0008C02A, sil_reb_mem((uint8_t *)0x0008C02A) & ~0x04);
|
---|
478 | uip_sethostaddr(s->ipaddr);
|
---|
479 | uip_setnetmask(s->netmask);
|
---|
480 | uip_setdraddr(s->default_router);
|
---|
481 | // resolv_conf(s->dnsaddr);
|
---|
482 | DHCP4_CLI_SET_ADDR_CALLBACK();
|
---|
483 | }
|
---|
484 | #endif /* __DHCPC_H__ */
|
---|
485 | /*---------------------------------------------------------------------------*/
|
---|
486 | clock_time_t clock_time(void)
|
---|
487 | {
|
---|
488 | return uiptsk.timer;
|
---|
489 | }
|
---|