1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Network library.
* Copyright (C) 1997 Kunihiro Ishiguro
*/
#include <zebra.h>
#include <fcntl.h>
#include "log.h"
#include "network.h"
#include "lib_errors.h"
/* Read nbytes from fd and store into ptr. */
int readn(int fd, uint8_t *ptr, int nbytes)
{
int nleft;
int nread;
nleft = nbytes;
while (nleft > 0) {
nread = read(fd, ptr, nleft);
if (nread < 0)
return (nread);
else if (nread == 0)
break;
nleft -= nread;
ptr += nread;
}
return nbytes - nleft;
}
/* Write nbytes from ptr to fd. */
int writen(int fd, const uint8_t *ptr, int nbytes)
{
int nleft;
int nwritten;
nleft = nbytes;
while (nleft > 0) {
nwritten = write(fd, ptr, nleft);
if (nwritten < 0) {
if (!ERRNO_IO_RETRY(errno))
return nwritten;
}
if (nwritten == 0)
return (nwritten);
nleft -= nwritten;
ptr += nwritten;
}
return nbytes - nleft;
}
int set_nonblocking(int fd)
{
int flags;
/* According to the Single UNIX Spec, the return value for F_GETFL
should
never be negative. */
flags = fcntl(fd, F_GETFL);
if (flags < 0) {
flog_err(EC_LIB_SYSTEM_CALL,
"fcntl(F_GETFL) failed for fd %d: %s", fd,
safe_strerror(errno));
return -1;
}
if (fcntl(fd, F_SETFL, (flags | O_NONBLOCK)) < 0) {
flog_err(EC_LIB_SYSTEM_CALL,
"fcntl failed setting fd %d non-blocking: %s", fd,
safe_strerror(errno));
return -1;
}
return 0;
}
int set_cloexec(int fd)
{
int flags;
flags = fcntl(fd, F_GETFD, 0);
if (flags == -1)
return -1;
flags |= FD_CLOEXEC;
if (fcntl(fd, F_SETFD, flags) == -1)
return -1;
return 0;
}
float htonf(float host)
{
uint32_t lu1, lu2;
float convert;
memcpy(&lu1, &host, sizeof(uint32_t));
lu2 = htonl(lu1);
memcpy(&convert, &lu2, sizeof(uint32_t));
return convert;
}
float ntohf(float net)
{
return htonf(net);
}
uint64_t frr_sequence_next(void)
{
static uint64_t last_sequence;
struct timespec ts;
(void)clock_gettime(CLOCK_MONOTONIC, &ts);
if (last_sequence == (uint64_t)ts.tv_sec) {
last_sequence++;
return last_sequence;
}
last_sequence = ts.tv_sec;
return last_sequence;
}
uint32_t frr_sequence32_next(void)
{
/* coverity[Y2K38_SAFETY] */
return (uint32_t)frr_sequence_next();
}
|
