FFmpeg
ip.c
Go to the documentation of this file.
1 /*
2  * IP common code
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public License
8  * as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public License
17  * along with FFmpeg; if not, write to the Free Software * Foundation, Inc.,
18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "ip.h"
22 #include "libavutil/avstring.h"
23 
24 static int compare_addr(const struct sockaddr_storage *a,
25  const struct sockaddr_storage *b)
26 {
27  if (a->ss_family != b->ss_family)
28  return 1;
29  if (a->ss_family == AF_INET) {
30  return (((const struct sockaddr_in *)a)->sin_addr.s_addr !=
31  ((const struct sockaddr_in *)b)->sin_addr.s_addr);
32  }
33 
34 #if HAVE_STRUCT_SOCKADDR_IN6
35  if (a->ss_family == AF_INET6) {
36  const uint8_t *s6_addr_a = ((const struct sockaddr_in6 *)a)->sin6_addr.s6_addr;
37  const uint8_t *s6_addr_b = ((const struct sockaddr_in6 *)b)->sin6_addr.s6_addr;
38  return memcmp(s6_addr_a, s6_addr_b, 16);
39  }
40 #endif
41  return 1;
42 }
43 
45 {
46  int i;
47  if (s->nb_exclude_addrs) {
48  for (i = 0; i < s->nb_exclude_addrs; i++) {
49  if (!compare_addr(source_addr_ptr, &s->exclude_addrs[i]))
50  return 1;
51  }
52  }
53  if (s->nb_include_addrs) {
54  for (i = 0; i < s->nb_include_addrs; i++) {
55  if (!compare_addr(source_addr_ptr, &s->include_addrs[i]))
56  return 0;
57  }
58  return 1;
59  }
60  return 0;
61 }
62 
63 struct addrinfo *ff_ip_resolve_host(void *log_ctx,
64  const char *hostname, int port,
65  int type, int family, int flags)
66 {
67  struct addrinfo hints = { 0 }, *res = 0;
68  int error;
69  char sport[16];
70  const char *node = 0, *service = "0";
71 
72  if (port > 0) {
73  snprintf(sport, sizeof(sport), "%d", port);
74  service = sport;
75  }
76  if ((hostname) && (hostname[0] != '\0') && (hostname[0] != '?')) {
77  node = hostname;
78  }
79  hints.ai_socktype = type;
80  hints.ai_family = family;
81  hints.ai_flags = flags;
82  if ((error = getaddrinfo(node, service, &hints, &res))) {
83  res = NULL;
84  av_log(log_ctx, AV_LOG_ERROR, "getaddrinfo(%s, %s): %s\n",
85  node ? node : "unknown",
86  service,
88  }
89 
90  return res;
91 }
92 
93 
94 static int ip_parse_addr_list(void *log_ctx, const char *buf,
95  struct sockaddr_storage **address_list_ptr,
96  int *address_list_size_ptr)
97 {
98  struct addrinfo *ai = NULL;
99 
100  /* Resolve all of the IPs */
101 
102  while (buf && buf[0]) {
103  char* host = av_get_token(&buf, ",");
104  if (!host)
105  return AVERROR(ENOMEM);
106 
107  ai = ff_ip_resolve_host(log_ctx, host, 0, SOCK_DGRAM, AF_UNSPEC, 0);
108  av_freep(&host);
109 
110  if (ai) {
111  struct sockaddr_storage source_addr = {0};
112  memcpy(&source_addr, ai->ai_addr, ai->ai_addrlen);
113  freeaddrinfo(ai);
114  av_dynarray2_add((void **)address_list_ptr, address_list_size_ptr, sizeof(source_addr), (uint8_t *)&source_addr);
115  if (!*address_list_ptr)
116  return AVERROR(ENOMEM);
117  } else {
118  return AVERROR(EINVAL);
119  }
120 
121  if (*buf)
122  buf++;
123  }
124 
125  return 0;
126 }
127 
128 static int ip_parse_sources_and_blocks(void *log_ctx, const char *buf, IPSourceFilters *filters, int parse_include_list)
129 {
130  int ret;
131  if (parse_include_list)
132  ret = ip_parse_addr_list(log_ctx, buf, &filters->include_addrs, &filters->nb_include_addrs);
133  else
134  ret = ip_parse_addr_list(log_ctx, buf, &filters->exclude_addrs, &filters->nb_exclude_addrs);
135 
136  if (ret >= 0 && filters->nb_include_addrs && filters->nb_exclude_addrs) {
137  av_log(log_ctx, AV_LOG_ERROR, "Simultaneously including and excluding sources is not supported.\n");
138  return AVERROR(EINVAL);
139  }
140  return ret;
141 }
142 
143 int ff_ip_parse_sources(void *log_ctx, const char *buf, IPSourceFilters *filters)
144 {
145  return ip_parse_sources_and_blocks(log_ctx, buf, filters, 1);
146 }
147 
148 int ff_ip_parse_blocks(void *log_ctx, const char *buf, IPSourceFilters *filters)
149 {
150  return ip_parse_sources_and_blocks(log_ctx, buf, filters, 0);
151 }
152 
154 {
155  av_freep(&filters->exclude_addrs);
156  av_freep(&filters->include_addrs);
157  filters->nb_include_addrs = 0;
158  filters->nb_exclude_addrs = 0;
159 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
ip_parse_addr_list
static int ip_parse_addr_list(void *log_ctx, const char *buf, struct sockaddr_storage **address_list_ptr, int *address_list_size_ptr)
Definition: ip.c:94
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ff_ip_parse_sources
int ff_ip_parse_sources(void *log_ctx, const char *buf, IPSourceFilters *filters)
Parses the address[,address] source list in buf and adds it to the filters in the IPSourceFilters str...
Definition: ip.c:143
av_get_token
char * av_get_token(const char **buf, const char *term)
Unescape the given string until a non escaped terminating char, and return the token corresponding to...
Definition: avstring.c:151
av_dynarray2_add
void * av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size, const uint8_t *elem_data)
Add an element of size elem_size to a dynamic array.
Definition: mem.c:350
b
#define b
Definition: input.c:40
sockaddr_storage
Definition: network.h:111
freeaddrinfo
#define freeaddrinfo
Definition: network.h:218
ff_ip_reset_filters
void ff_ip_reset_filters(IPSourceFilters *filters)
Resets the IP filter list and frees the internal fields of an IPSourceFilters structure.
Definition: ip.c:153
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
ip_parse_sources_and_blocks
static int ip_parse_sources_and_blocks(void *log_ctx, const char *buf, IPSourceFilters *filters, int parse_include_list)
Definition: ip.c:128
filters
#define filters(fmt, inverse, clip, i, c)
Definition: af_crystalizer.c:221
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
s
#define s(width, name)
Definition: cbs_vp9.c:257
compare_addr
static int compare_addr(const struct sockaddr_storage *a, const struct sockaddr_storage *b)
Definition: ip.c:24
NULL
#define NULL
Definition: coverity.c:32
ff_ip_parse_blocks
int ff_ip_parse_blocks(void *log_ctx, const char *buf, IPSourceFilters *filters)
Parses the address[,address] source block list in buf and adds it to the filters in the IPSourceFilte...
Definition: ip.c:148
addrinfo::ai_addr
struct sockaddr * ai_addr
Definition: network.h:143
ff_ip_resolve_host
struct addrinfo * ff_ip_resolve_host(void *log_ctx, const char *hostname, int port, int type, int family, int flags)
Resolves hostname into an addrinfo structure.
Definition: ip.c:63
addrinfo::ai_family
int ai_family
Definition: network.h:139
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
gai_strerror
#define gai_strerror
Definition: network.h:225
addrinfo::ai_addrlen
int ai_addrlen
Definition: network.h:142
getaddrinfo
#define getaddrinfo
Definition: network.h:217
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
ip.h
ret
ret
Definition: filter_design.txt:187
addrinfo::ai_socktype
int ai_socktype
Definition: network.h:140
addrinfo::ai_flags
int ai_flags
Definition: network.h:138
IPSourceFilters
Structure for storing IP (UDP) source filters or block lists.
Definition: ip.h:29
ff_ip_check_source_lists
int ff_ip_check_source_lists(struct sockaddr_storage *source_addr_ptr, IPSourceFilters *s)
Checks the source address against a given IP source filter.
Definition: ip.c:44
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
avstring.h
addrinfo
Definition: network.h:137
snprintf
#define snprintf
Definition: snprintf.h:34