gatuno
/
NetworkInador
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: gatuno:dab460efb6aaa1a3f4fbc96a497fb666f05d60d9
Branches Tags
gatuno:master
..
compare: gatuno:050fa2893a220abf5e586559fe97aae062204c09
Branches Tags
gatuno:master

No commits in common. "dab460efb6aaa1a3f4fbc96a497fb666f05d60d9" and "050fa2893a220abf5e586559fe97aae062204c09" have entirely different histories.
dab460efb6 ... 050fa2893a

56 changed files with 1183 additions and 2594 deletions
Show Stats Expand all files Collapse all files

4
.gitignore vendored
View File

@ -19,12 +19,8 @@ config.log
config.status
.deps
src/network-inador
lib/libnetworkinador.la
lib/network-inador.pc
src/dhcpc/nidhcpc
*.o
*.lo
.libs
stamp-h1
*~

2
Makefile.am
View File

@ -1,4 +1,4 @@
SUBDIRS = common lib src client-gtk po
SUBDIRS = src client-gtk po
ACLOCAL_AMFLAGS = -I m4

2
client-gtk/Makefile.am
View File

@ -20,7 +20,7 @@ inador_gtk_client_SOURCES = main.c \
#inador_gtk_client_CPPFLAGS = -DGAMEDATA_DIR=\"$(gamedatadir)/\" -DLOCALEDIR=\"$(localedir)\" $(AM_CPPFLAGS)
inador_gtk_client_CPPFLAGS = -DLOCALEDIR=\"$(localedir)\" $(AM_CPPFLAGS)
inador_gtk_client_CFLAGS = -I$(top_srcdir)/lib $(GTK_CFLAGS) $(AM_CFLAGS)
inador_gtk_client_CFLAGS = $(GTK_CFLAGS) $(AM_CFLAGS)
inador_gtk_client_LDADD = $(GTK_LIBS)
LDADD = $(LIBINTL)

2
client-gtk/main.c
View File

@ -7,7 +7,7 @@
#include "ni-window-interface.h"
#include "ni-window-route.h"
#include "network-inador-link-types.h"
#include "../src/link-types.h"
enum {
COL_IFACE_OBJECT,

2
client-gtk/ni-interface-chooser-dialog.c
View File

@ -33,7 +33,7 @@
#include "ni-interface.h"
#include "ni-interface-filter.h"
#include "network-inador-link-types.h"
#include "../src/link-types.h"
enum {
COL_INTERFACE_CHOOSER_NAME,

2
client-gtk/ni-window-interface.c
View File

@ -38,7 +38,7 @@
#include "ni-interface.h"
#include "ni-ip.h"
#include "ni-add-ip-dialog.h"
#include "network-inador-link-types.h"
#include "../src/link-types.h"
#include "ni-interface-chooser-dialog.h"
#include "ni-interface-filter.h"

12
common/Makefile.am
View File

@ -1,12 +0,0 @@
#noinst_LIBRARIES = libnicommon.a
#libnicommon_a_SOURCES = flist.c flist.h
# resolv_conf_parser.c resolv_conf_parser.h
# utils.c utils.h
EXTRA_DIST = flist.c flist.h \
resolv_conf_parser.c resolv_conf_parser.h \
utils.c utils.h
#libnicommon_a_CPPFLAGS = -DSHAREDATA_DIR=\"$(sharedatadir)/\" -DLOCALEDIR=\"$(localedir)\" $(AM_CPPFLAGS)
#libnicommon_a_CFLAGS = -I$(top_srcdir)/lib $(AM_CFLAGS)
#LDADD = $(LIBINTL)

150
common/flist.h
View File

@ -1,150 +0,0 @@
/* GLIB - Library of useful routines for C programming
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
/*
* Modified by the GLib Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GLib Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GLib at ftp://ftp.gtk.org/pub/gtk/.
*/
#ifndef __F_LIST_H__
#define __F_LIST_H__
#define F_GNUC_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
typedef void (*FDestroyNotify) (void * data);
typedef void (*FFunc) (void * data, void * user_data);
typedef int (*FCompareDataFunc) (const void * a, const void * b, void * user_data);
typedef int (*FCompareFunc) (const void * a, const void * b);
typedef void * (*FCopyFunc) (const void * src, void * data);
typedef struct _FList FList;
struct _FList
{
void * data;
FList *next;
FList *prev;
};
/* Doubly linked lists
*/
FList* f_list_alloc (void) F_GNUC_WARN_UNUSED_RESULT;
void f_list_free (FList *list);
void f_list_free_1 (FList *list);
#define f_list_free1 f_list_free_1
void f_list_free_full (FList *list,
FDestroyNotify free_func);
FList* f_list_append (FList *list,
void * data) F_GNUC_WARN_UNUSED_RESULT;
FList* f_list_prepend (FList *list,
void * data) F_GNUC_WARN_UNUSED_RESULT;
FList* f_list_insert (FList *list,
void * data,
int position) F_GNUC_WARN_UNUSED_RESULT;
FList* f_list_insert_sorted (FList *list,
void * data,
FCompareFunc func) F_GNUC_WARN_UNUSED_RESULT;
FList* f_list_insert_sorted_with_data (FList *list,
void * data,
FCompareDataFunc func,
void * user_data) F_GNUC_WARN_UNUSED_RESULT;
FList* f_list_insert_before (FList *list,
FList *sibling,
void * data) F_GNUC_WARN_UNUSED_RESULT;
FList* f_list_concat (FList *list1,
FList *list2) F_GNUC_WARN_UNUSED_RESULT;
FList* f_list_remove (FList *list,
const void * data) F_GNUC_WARN_UNUSED_RESULT;
FList* f_list_remove_all (FList *list,
const void * data) F_GNUC_WARN_UNUSED_RESULT;
FList* f_list_remove_link (FList *list,
FList *llink) F_GNUC_WARN_UNUSED_RESULT;
FList* f_list_delete_link (FList *list,
FList *link_) F_GNUC_WARN_UNUSED_RESULT;
FList* f_list_reverse (FList *list) F_GNUC_WARN_UNUSED_RESULT;
FList* f_list_copy (FList *list) F_GNUC_WARN_UNUSED_RESULT;
FList* f_list_copy_deep (FList *list,
FCopyFunc func,
void * user_data) F_GNUC_WARN_UNUSED_RESULT;
FList* f_list_nth (FList *list,
unsigned int n);
FList* f_list_nth_prev (FList *list,
unsigned int n);
FList* f_list_find (FList *list,
const void * data);
FList* f_list_find_custom (FList *list,
const void * data,
FCompareFunc func);
int f_list_position (FList *list,
FList *llink);
int f_list_index (FList *list,
const void * data);
FList* f_list_last (FList *list);
FList* f_list_first (FList *list);
unsigned int f_list_length (FList *list);
void f_list_foreach (FList *list,
FFunc func,
void * user_data);
FList* f_list_sort (FList *list,
FCompareFunc compare_func) F_GNUC_WARN_UNUSED_RESULT;
FList* f_list_sort_with_data (FList *list,
FCompareDataFunc compare_func,
void * user_data) F_GNUC_WARN_UNUSED_RESULT;
void * f_list_nth_data (FList *list,
unsigned int n);
#define f_list_previous(list) ((list) ? (((FList *)(list))->prev) : NULL)
#define f_list_next(list) ((list) ? (((FList *)(list))->next) : NULL)
#endif /* __F_LIST_H__ */

109
common/network-inador-manager.h
View File

@ -1,109 +0,0 @@
#ifndef __NETWOR_INADOR_MANAGER_H__
#define __NETWOR_INADOR_MANAGER_H__
enum {
NET_INADOR_TYPE_COMMAND = 1,
NET_INADOR_TYPE_RESPONSE = 2,
NET_INADOR_TYPE_RESPONSE_ERROR = 3,
NET_INADOR_TYPE_RESPONSE_LISTING_END = 4,
NET_INADOR_TYPE_EVENT = 16
};
/* Lista de eventos */
#define NET_INADOR_EVENT_MASK_INTERFACES 0x01
#define NET_INADOR_EVENT_MASK_IP 0x02
#define NET_INADOR_EVENT_MASK_DHCP_STATUS 0x04
#define NET_INADOR_EVENT_MASK_ROUTES 0x08
#define NET_INADOR_EVENT_MASK_ROUTE_TABLES 0x10
enum {
NET_INADOR_COMMAND_LIST_IFACES = 1,
NET_INADOR_COMMAND_GET_IFACE,
NET_INADOR_COMMAND_IFACE_UP,
NET_INADOR_COMMAND_IFACE_DOWN,
NET_INADOR_COMMAND_IFACE_CHANGE_NAME,
NET_INADOR_COMMAND_IFACE_CHANGE_MTU,
NET_INADOR_COMMAND_CREATE_BRIDGE = 16,
NET_INADOR_COMMAND_CLEAR_MASTER,
NET_INADOR_COMMAND_SET_MASTER,
NET_INADOR_COMMAND_LIST_IP = 32,
NET_INADOR_COMMAND_CLEAR_IP,
NET_INADOR_COMMAND_ADD_IP,
NET_INADOR_COMMAND_REMOVE_IP,
NET_INADOR_COMMAND_RUN_DHCP = 48,
NET_INADOR_COMMAND_STOP_DHCP,
NET_INADOR_COMMAND_GET_DHCP_STATUS,
NET_INADOR_COMMAND_LIST_ROUTES = 64,
NET_INADOR_COMMAND_ADD_ROUTE,
NET_INADOR_COMMAND_REMOVE_ROUTE,
NET_INADOR_COMMAND_LIST_ROUTE_TABLES = 72,
NET_INADOR_COMMAND_SET_EVENT_MASK = 192,
/* Los siguientes comandos son para uso interno */
NET_INADOR_COMMAND_DHCP_CLIENT_FEED = 224,
NET_INADOR_COMMAND_RESOLVCONF_FEED = 225,
NET_INADOR_COMMAND_RESOLVCONF_REMOVE = 226,
};
enum {
NET_INADOR_ERROR_UNKNOWN = 0,
NET_INADOR_ERROR_WRONG_COMMAND,
NET_INADOR_ERROR_INCOMPLETE_REQUEST,
NET_INADOR_ERROR_INVALID_IFACE_INDEX,
NET_INADOR_ERROR_INVALID_FAMILY,
NET_INADOR_ERROR_INVALID_VALUE,
NET_INADOR_ERROR_NOT_EXECUTED,
NET_INADOR_ERROR_BAD_STRING,
};
enum {
NET_INADOR_EVENT_IFACE_ADDED = 2,
NET_INADOR_EVENT_IPADDR_ADDED,
NET_INADOR_EVENT_IFACE_REMOVED,
NET_INADOR_EVENT_IPADDR_REMOVED,
NET_INADOR_EVENT_DHCP_STATUS = 6,
NET_INADOR_EVENT_ROUTE_ADDED = 10,
NET_INADOR_EVENT_ROUTE_REMOVED,
NET_INADOR_EVENT_ROUTE_TABLE_ADDED = 14,
NET_INADOR_EVENT_ROUTE_TABLE_REMOVED,
};
enum {
NET_INADOR_RESPONSE_EXECUTED = 1,
NET_INADOR_RESPONSE_IFACE = 2,
NET_INADOR_RESPONSE_IPADDR,
NET_INADOR_RESPONSE_DHCP_STATUS = 6,
NET_INADOR_RESPONSE_ROUTE = 10,
NET_INADOR_RESPONSE_ROUTE_TABLE = 14
};
enum {
NET_INADOR_DHCP_STATUS_SELECTING = 1,
NET_INADOR_DHCP_STATUS_BOUND,
NET_INADOR_DHCP_STATUS_RENEWED,
NET_INADOR_DHCP_STATUS_EXPIRED,
NET_INADOR_DHCP_STATUS_FAILED,
};
#endif /* __NETWOR_INADOR_MANAGER_H__ */

10
configure.ac
View File

@ -13,7 +13,7 @@ AC_PREFIX_DEFAULT([/usr])
AC_PROG_CC
# and automake
AM_INIT_AUTOMAKE([-Wall -Werror subdir-objects])
AM_INIT_AUTOMAKE([-Wall -Werror])
# Translate this program
AM_GNU_GETTEXT_VERSION([0.19.8])
@ -22,11 +22,6 @@ AM_GNU_GETTEXT([external])
ALL_LINGUAS=""
AC_SUBST(ALL_LINGUAS)
AM_PROG_AR
# Es una libreria, necesitamos libtool
LT_INIT
AM_PROG_CC_C_O
# Revisar el host
@ -66,9 +61,6 @@ AC_CONFIG_HEADERS([config.h])
AC_CONFIG_FILES([
Makefile
common/Makefile
lib/Makefile
lib/network-inador.pc
src/Makefile
client-gtk/Makefile
po/Makefile.in

35
lib/Makefile.am
View File

@ -1,35 +0,0 @@
lib_LTLIBRARIES = libnetworkinador.la
libnetworkinador_la_SOURCES = network-inador.h \
network-inador-private.h \
network-inador-link-types.h \
struct_addr_union.h wireless_struct.h \
handle.c \
netlink-events.c netlink-events.h \
interfaces.c interfaces.h \
ip-address.c ip-address.h \
routes.c routes.h \
launch_process.c launch_process.h \
dhcp_client.c dhcp_client.h dhcpc_defs.h \
wireless_if.c wireless_if.h \
wireless_bss.c wireless_bss.h \
veth.c veth.h \
resolv_manager.c resolv_manager.h \
resolv_conf_defs.h \
bridge.c bridge.h \
../common/flist.c ../common/flist.h \
../common/resolv_conf_parser.c ../common/resolv_conf_parser.h \
../common/utils.c ../common/utils.h
#wireless-security.c wireless-security.h
libnetworkinador_la_CPPFLAGS = -DSHAREDATA_DIR=\"$(sharedatadir)/\" -DLOCALEDIR=\"$(localedir)\" $(AM_CPPFLAGS)
libnetworkinador_la_LIBADD = $(LIBNL3_LIBS) $(LIBNLGEN3_LIBS)
#../common/libnicommon.a
libnetworkinador_la_CFLAGS = -I$(top_srcdir)/common $(LIBNL3_CFLAGS) $(LIBNLGEN3_CFLAGS) $(AM_CFLAGS)
LDADD = $(LIBINTL)
libnetworkinadordir = $(includedir)/libnetworkinador
libnetworkinador_HEADERS = network-inador.h network-inador-link-types.h
pkgconfigdir = $(libdir)/pkgconfig
dist_pkgconfig_DATA = network-inador.pc

314
lib/handle.c
View File

@ -1,314 +0,0 @@
/*
* main.c
* This file is part of Network-inador
*
* Copyright (C) 2024 - Félix Arreola Rodríguez
*
* Network-inador is free software; 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 2 of the License, or
* (at your option) any later version.
*
* Network-inador is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Network-inador; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <fcntl.h>
#include <unistd.h>
#include <assert.h>
#include <sys/types.h>
#include <signal.h>
#include <sys/wait.h>
#include "network-inador-private.h"
#include "netlink-events.h"
#include "interfaces.h"
#include "routes.h"
#include "resolv_manager.h"
struct _NetworkInadorWatchedPID {
unsigned int source;
pid_t child_pid;
NetworkInadorChildWatchFunc func;
void *data;
};
/* Variables si nosotros hacemos vigilancia de procesos */
static FList *network_inador_watched_childs = NULL;
static unsigned int network_inador_watched_child_source_counter = 1;
static int network_inador_pipes_child_notify[2] = {-1, -1};
static int network_inador_child_source_watcher = 0;
static unsigned int network_inador_add_watch_process (pid_t pid, NetworkInadorChildWatchFunc func, void *user_data) {
struct _NetworkInadorWatchedPID *watcher;
watcher = (struct _NetworkInadorWatchedPID *) malloc (sizeof (struct _NetworkInadorWatchedPID));
assert (watcher != NULL);
watcher->source = network_inador_watched_child_source_counter;
network_inador_watched_child_source_counter++;
watcher->child_pid = pid;
watcher->func = func;
watcher->data = user_data;
network_inador_watched_childs = f_list_append (network_inador_watched_childs, watcher);
return watcher->source;
}
static void network_inador_remove_watch_process (unsigned int source) {
/* Recorrer la lista para eliminar el watch, ignorar si no está en la lista */
struct _NetworkInadorWatchedPID *watcher;
FList *g, *next;
g = network_inador_watched_childs;
while (g != NULL) {
next = g->next;
watcher = (struct _NetworkInadorWatchedPID *) g->data;
if (watcher->source == source) {
network_inador_watched_childs = f_list_delete_link (network_inador_watched_childs, g);
free (watcher);
break;
}
g = next;
}
}
static void _network_inador_try_setup_route_events (NetworkInadorHandle *handle) {
struct nl_sock * sock_req;
sock_req = nl_socket_alloc ();
int fd;
if (nl_connect (sock_req, NETLINK_ROUTE) != 0) {
nl_socket_free (sock_req);
return;
}
nl_socket_set_nonblocking (sock_req);
nl_socket_disable_seq_check (sock_req);
fd = nl_socket_get_fd (sock_req);
/* Set close-on-exec */
fcntl (fd, F_SETFD, FD_CLOEXEC);
handle->route_events.nl_sock = sock_req;
handle->has_route_events = 1;
handle->route_events.source = handle->ops.input_add (fd, POLLIN, netlink_events_route_events_handle_read, handle);
nl_socket_add_memberships (sock_req, RTNLGRP_LINK, RTNLGRP_IPV4_IFADDR, RTNLGRP_IPV6_IFADDR, RTNLGRP_IPV6_IFINFO, RTNLGRP_IPV4_ROUTE, RTNLGRP_IPV6_ROUTE, 0);
nl_socket_modify_cb (sock_req, NL_CB_VALID, NL_CB_CUSTOM, netlink_events_route_dispatcher, handle);
}
static void _network_inador_try_pipe_routes (NetworkInadorHandle *handle) {
int ret, flags;
int pipe_fds[2];
ret = pipe (pipe_fds);
if (ret < 0) {
return;
}
handle->pipe_routes[0] = pipe_fds[0];
handle->pipe_routes[1] = pipe_fds[1];
flags = fcntl (pipe_fds[0], F_GETFL);
fcntl (pipe_fds[0], F_SETFL, flags | O_NONBLOCK);
handle->source_pipe_routes = handle->ops.input_add (pipe_fds[0], POLLIN, netlink_events_pipe_route_handle_read, handle);
}
static void network_inador_signal_handler_child (int signum) {
//fprintf (stderr, "SIGCHLD session handler\n");
char byte = 1;
/* Avisar que un proceso hijo murió */
if (network_inador_pipes_child_notify[1] >= 0) {
write (network_inador_pipes_child_notify[1], &byte, 1);
}
}
static void network_inador_child_pipe_read (void *data, int fd, int condition) {
pid_t pid;
int status;
FList *g, *next;
char byte;
struct _NetworkInadorWatchedPID *watcher;
int n;
n = read (fd, &byte, 1);
if (n <= 0) return;
while ((pid = waitpid (-1, &status, WNOHANG)) > 0) {
g = network_inador_watched_childs;
fprintf (stderr, "El proceso hijo murió: %i\n", pid);
while (g != NULL) {
next = g->next;
watcher = (struct _NetworkInadorWatchedPID *) g->data;
if (watcher->child_pid == pid) {
/* Este es la vigilancia del proceso que buscamos */
watcher->func (watcher->data, pid, status);
/* Como ya murió el proceso, lo eliminamos de la lista de vigilancia */
network_inador_watched_childs = f_list_delete_link (network_inador_watched_childs, g);
free (watcher);
break;
}
g = next;
}
}
}
void network_inador_setup_child_handler (NetworkInadorHandle *handle) {
struct sigaction act;
sigset_t empty_mask;
if (handle->ops.input_add == NULL) {
/* No tenemos vigilancia de entrada, no podemos manejar las señales */
return;
}
if (pipe (network_inador_pipes_child_notify) != 0) {
return;
}
/* Queremos que estos pipes se cierren automáticamente */
fcntl (network_inador_pipes_child_notify[0], F_SETFD, FD_CLOEXEC);
fcntl (network_inador_pipes_child_notify[1], F_SETFD, FD_CLOEXEC);
/* Establecer un manejador de SIGCHLD para los procesos hijos que se generen */
sigemptyset (&empty_mask);
act.sa_mask = empty_mask;
act.sa_flags = 0;
act.sa_handler = &network_inador_signal_handler_child;
if (sigaction (SIGCHLD, &act, NULL) < 0) {
perror ("Failed to register SIGCHLD handler");
close (network_inador_pipes_child_notify[0]);
network_inador_pipes_child_notify[0] = -1;
close (network_inador_pipes_child_notify[1]);
network_inador_pipes_child_notify[1] = -1;
return;
}
network_inador_child_source_watcher = handle->ops.input_add (network_inador_pipes_child_notify[0], POLLIN, network_inador_child_pipe_read, handle);
handle->ops.process_watch = network_inador_add_watch_process;
handle->ops.process_unwatch = network_inador_remove_watch_process;
}
NetworkInadorHandle * network_inador_init_handle (struct NetworkInadorOps *network_inador_ops) {
NetworkInadorHandle *handle;
struct nl_sock * sock_req;
handle = (NetworkInadorHandle *) malloc (sizeof (NetworkInadorHandle));
assert (handle != NULL);
memset (handle, 0, sizeof (NetworkInadorHandle));
handle->pipe_routes[0] = -1;
handle->pipe_routes[1] = -1;
/* Copiar la información de eventos para vigilancia */
handle->ops = *network_inador_ops;
/* Crear el socket de peticiones */
sock_req = nl_socket_alloc ();
if (nl_connect (sock_req, NETLINK_ROUTE) != 0) {
perror ("Falló conectar netlink socket\n");
free (handle);
return NULL;
}
handle->nl_sock_route = sock_req;
/* Si tenemos una ops de configuración de eventos, entonces, configurar el otro socket de eventos async */
if (handle->ops.input_add != NULL) {
_network_inador_try_setup_route_events (handle);
_network_inador_try_pipe_routes (handle);
}
/* Inicializar las interfaces (y las direcciones IP) */
interfaces_init (handle);
/* Inicializar las rutas */
routes_init (handle);
/* Inicializar el resolv.conf */
resolv_manager_init (handle);
return handle;
}
void network_inador_destroy_handle (NetworkInadorHandle *handle) {
if (network_inador_pipes_child_notify[0] >= 0) {
if (handle->ops.input_remove != NULL) {
handle->ops.input_remove (network_inador_child_source_watcher);
network_inador_child_source_watcher = 0;
}
close (network_inador_pipes_child_notify[0]);
network_inador_pipes_child_notify[0] = -1;
}
if (network_inador_pipes_child_notify[1] >= 0) {
close (network_inador_pipes_child_notify[1]);
network_inador_pipes_child_notify[1] = -1;
}
if (handle->has_route_events) {
/* Quitar la vigilancia */
handle->ops.input_remove (handle->route_events.source);
handle->route_events.source = 0;
/* Cerrar el socket de eventos */
nl_socket_free (handle->route_events.nl_sock);
handle->route_events.nl_sock = NULL;
}
if (handle->source_pipe_routes != 0) {
handle->ops.input_remove (handle->source_pipe_routes);
handle->source_pipe_routes = 0;
}
if (handle->pipe_routes[0] >= 0) {
close (handle->pipe_routes[0]);
handle->pipe_routes[0] = -1;
}
if (handle->pipe_routes[1] >= 0) {
close (handle->pipe_routes[1]);
handle->pipe_routes[1] = -1;
}
/* TODO: Liberar las listas ligadas aquí */
routes_clean_up (handle);
interfaces_clean_up (handle);
nl_socket_free (handle->nl_sock_route);
handle->nl_sock_route = NULL;
free (handle);
}

331
lib/launch_process.c
View File

@ -1,331 +0,0 @@
/*
* lauch_process.c
* This file is part of Network-Inador
*
* Copyright (C) 2024 - Félix Arreola Rodríguez
*
* Network-Inador is free software; 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 2 of the License, or
* (at your option) any later version.
*
* Network-Inador is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Network-Inador; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
static ssize_t write_all (int fd, const void * vbuf, size_t to_write) {
char *buf = (char *) vbuf;
while (to_write > 0) {
ssize_t count = write (fd, buf, to_write);
if (count < 0) {
if (errno != EINTR)
return 0;
} else {
to_write -= count;
buf += count;
}
}
return 1;
}
/* This function is called between fork() and exec() and hence must be
* async-signal-safe (see signal-safety(7)). */
static void write_err_and_exit (int fd, int msg) {
int en = errno;
write_all (fd, &msg, sizeof (msg));
write_all (fd, &en, sizeof (en));
_exit (1);
}
static int safe_close (int fd) {
int ret;
do {
ret = close (fd);
} while (ret < 0 && errno == EINTR);
return ret;
}
static void close_and_invalidate (int *fd) {
if (*fd < 0) {
return;
} else {
safe_close (*fd);
*fd = -1;
}
}
static int safe_dup2 (int fd1, int fd2) {
int ret;
do {
ret = dup2 (fd1, fd2);
} while (ret < 0 && (errno == EINTR || errno == EBUSY));
return ret;
}
static int read_ints (int fd, int *buf, int n_ints_in_buf, int *n_ints_read, int *error) {
size_t bytes = 0;
while (1) {
ssize_t chunk;
if (bytes >= sizeof (int) * 2)
break; /* give up, who knows what happened, should not be possible. */
again:
chunk = read (fd,((char *) buf) + bytes, sizeof (int) * n_ints_in_buf - bytes);
if (chunk < 0 && errno == EINTR)
goto again;
if (chunk < 0) {
if (error != NULL) {
*error = errno;
}
return 0;
} else if (chunk == 0) {
break; /* EOF */
} else {/* chunk > 0 */
bytes += chunk;
}
}
*n_ints_read = (int) (bytes / sizeof (int));
return 1;
}
enum {
CHILD_CHDIR_FAILED,
CHILD_EXEC_FAILED,
CHILD_DUP2_FAILED,
CHILD_FORK_FAILED
};
static void do_exec (int child_err_report_fd, int stdin_fd, int stdout_fd, int stderr_fd, const char *working_directory, char **argv, char **envp) {
if (working_directory && chdir (working_directory) < 0) {
write_err_and_exit (child_err_report_fd, CHILD_CHDIR_FAILED);
}
if (stdin_fd >= 0) {
if (safe_dup2 (stdin_fd, 0) < 0) {
write_err_and_exit (child_err_report_fd, CHILD_DUP2_FAILED);
}
close (stdin_fd);
} else {
int read_null = open ("/dev/null", O_RDONLY);
if (read_null < 0) {
write_err_and_exit (child_err_report_fd, CHILD_DUP2_FAILED);
}
safe_dup2 (read_null, 0);
close_and_invalidate (&read_null);
}
if (stdout_fd >= 0) {
if (safe_dup2 (stdout_fd, 1) < 0) {
write_err_and_exit (child_err_report_fd, CHILD_DUP2_FAILED);
}
close (stdout_fd);
} else {
int read_null = open ("/dev/null", O_WRONLY);
if (read_null < 0) {
write_err_and_exit (child_err_report_fd, CHILD_DUP2_FAILED);
}
safe_dup2 (read_null, 1);
close_and_invalidate (&read_null);
}
/* Ahora para stderr */
if (stderr_fd >= 0) {
if (safe_dup2 (stderr_fd, 2) < 0) {
write_err_and_exit (child_err_report_fd, CHILD_DUP2_FAILED);
}
close (stderr_fd);
} else {
int read_null = open ("/dev/null", O_WRONLY);
if (read_null < 0) {
write_err_and_exit (child_err_report_fd, CHILD_DUP2_FAILED);
}
safe_dup2 (read_null, 2);
close_and_invalidate (&read_null);
}
/* TODO: Si queremos cerrar todos los descriptores, este es el momento */
fcntl (child_err_report_fd, F_SETFD, FD_CLOEXEC);
/* Hacer el exec */
execvpe (argv[0], argv, envp);
write_err_and_exit (child_err_report_fd, CHILD_EXEC_FAILED);
}
static int fork_exec_with_fds (const char *working_directory, char **argv, char **envp, pid_t *child_pid, int *child_close_fds, int stdin_fd, int stdout_fd, int stderr_fd, int *error) {
pid_t pid;
int child_err_report_pipe[2] = { -1, -1 };
if (pipe (child_err_report_pipe) != 0) {
if (error != NULL) *error = errno;
return 0;
}
pid = fork ();
if (pid < 0) {
if (error != NULL) *error = errno;
goto cleanup_and_fail;
} else if (pid == 0) {
/* Proceso intermedio */
/* Reset some signal handlers that we may use */
signal (SIGCHLD, SIG_DFL);
signal (SIGINT, SIG_DFL);
signal (SIGTERM, SIG_DFL);
signal (SIGHUP, SIG_DFL);
/* Be sure we crash if the parent exits
* and we write to the err_report_pipe
*/
signal (SIGPIPE, SIG_DFL);
/* Close the parent's end of the pipes;
* not needed in the close_descriptors case,
* though
*/
close_and_invalidate (&child_err_report_pipe[0]);
if (child_close_fds != NULL) {
int i = -1;
while (child_close_fds[++i] != -1)
close_and_invalidate (&child_close_fds[i]);
}
do_exec (child_err_report_pipe[1], stdin_fd, stdout_fd, stderr_fd, working_directory, argv, envp);
} else {
/* Proceso padre */
int buf[2];
int n_ints = 0;
close_and_invalidate (&child_err_report_pipe[1]);
if (!read_ints (child_err_report_pipe[0], buf, 2, &n_ints, error)) {
goto cleanup_and_fail;
}
if (n_ints >= 2) {
/* El argumento buf[0] tiene el error, el buf[1] tiene el errno del proceso hijo */
if (error != NULL) *error = buf[1];
goto cleanup_and_fail;
}
close_and_invalidate (&child_err_report_pipe[0]);
if (child_pid) {
*child_pid = pid;
}
return 1;
}
cleanup_and_fail:
if (pid > 0) {
wait_failed:
if (waitpid (pid, NULL, 0) < 0) {
if (errno == EINTR)
goto wait_failed;
else if (errno == ECHILD)
; /* do nothing, child already reaped */
/*else
g_warning ("waitpid() should not fail in 'fork_exec_with_pipes'");*/
}
}
close_and_invalidate (&child_err_report_pipe[0]);
close_and_invalidate (&child_err_report_pipe[1]);
return 0;
}
int launch_process (const char *working_directory, char **argv, char **envp, pid_t *child_pid, int *standard_input, int *standard_output, int *standard_error, int *error) {
int stdin_pipe[2] = { -1, -1 };
int stdout_pipe[2] = { -1, -1 };
int stderr_pipe[2] = { -1, -1 };
int child_close_fds[4];
int c;
int ret;
if (standard_input && pipe (stdin_pipe) != 0)
goto failed_launch_cleanup;
if (standard_output && pipe (stdout_pipe) != 0)
goto failed_launch_cleanup;
if (standard_error && pipe (stderr_pipe) != 0)
goto failed_launch_cleanup;
c = 0;
if (stdin_pipe[1] != -1) child_close_fds[c++] = stdin_pipe[1];
if (stdout_pipe[0] != -1) child_close_fds[c++] = stdout_pipe[0];
if (stderr_pipe[0] != -1) child_close_fds[c++] = stderr_pipe[0];
child_close_fds[c++] = -1;
ret = fork_exec_with_fds (working_directory, argv, envp, child_pid, child_close_fds, stdin_pipe[0], stdout_pipe[1], stderr_pipe[1], error);
if (!ret) goto failed_launch_cleanup;
close_and_invalidate (&stdin_pipe[0]);
close_and_invalidate (&stdout_pipe[1]);
close_and_invalidate (&stderr_pipe[1]);
if (standard_input) {
*standard_input = stdin_pipe[1];
}
if (standard_output) {
*standard_output = stdout_pipe[0];
}
if (standard_error) {
*standard_error = stderr_pipe[0];
}
return 1;
failed_launch_cleanup:
close_and_invalidate (&stdin_pipe[0]);
close_and_invalidate (&stdin_pipe[1]);
close_and_invalidate (&stdout_pipe[0]);
close_and_invalidate (&stdout_pipe[1]);
close_and_invalidate (&stderr_pipe[0]);
close_and_invalidate (&stderr_pipe[1]);
return 0;
}

29
lib/launch_process.h
View File

@ -1,29 +0,0 @@
/*
* launch_process.h
* This file is part of Network-Inador
*
* Copyright (C) 2024 - Félix Arreola Rodríguez
*
* Network-Inador is free software; 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 2 of the License, or
* (at your option) any later version.
*
* Network-Inador is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Network-Inador; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#ifndef __LAUNCH_PROCESS_H__
#define __LAUNCH_PROCESS_H__
int launch_process (const char *working_directory, char **argv, char **envp, pid_t *child_pid, int *standard_input, int *standard_output, int *standard_error, int *error);
#endif /* __LAUNCH_PROCESS_H__ */

91
lib/netlink-events.c
View File

@ -1,91 +0,0 @@
/*
* netlink-events.c
* This file is part of Network-inador
*
* Copyright (C) 2019, 2020 - Félix Arreola Rodríguez
*
* Network-inador is free software; 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 2 of the License, or
* (at your option) any later version.
*
* Network-inador is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Network-inador; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#include <stdio.h>
#include <unistd.h>
#include <netlink/socket.h>
#include <netlink/msg.h>
#include <linux/nl80211.h>
#include <fcntl.h>
#include "network-inador-private.h"
#include "interfaces.h"
#include "ip-address.h"
#include "routes.h"
int netlink_events_route_dispatcher (struct nl_msg *msg, void *arg) {
struct nlmsghdr *reply;
reply = nlmsg_hdr (msg);
switch (reply->nlmsg_type) {
case RTM_NEWLINK:
return interface_receive_message_newlink (msg, arg);
break;
case RTM_DELLINK:
return interface_receive_message_dellink (msg, arg);
break;
case RTM_NEWADDR:
return ip_address_receive_message_newaddr (msg, arg);
break;
case RTM_DELADDR:
return ip_address_receive_message_deladdr (msg, arg);
break;
case RTM_NEWROUTE:
return routes_receive_message_newroute (msg, arg);
break;
case RTM_DELROUTE:
return routes_receive_message_delroute (msg, arg);
break;
}
return NL_SKIP;
}
void netlink_events_route_events_handle_read (void *data, int fd, int condition) {
NetworkInadorHandle *handle = (NetworkInadorHandle *) data;
nl_recvmsgs_default (handle->route_events.nl_sock);
}
void netlink_events_pipe_route_handle_read (void *data, int fd, int condition) {
NetworkInadorHandle *handle = (NetworkInadorHandle *) data;
char buffer[8192];
int ret;
ret = read (handle->pipe_routes[0], buffer, sizeof (buffer));
if (ret > 0) {
/* Leimos algo en el aviso de re-procesar rutas */
routes_ask (handle);
} else if (ret == 0) {
/* Cerrar el pipe */
close (handle->pipe_routes[0]);
handle->pipe_routes[0] = -1;
handle->ops.input_remove (handle->source_pipe_routes);
handle->source_pipe_routes = 0;
}
}

75
lib/network-inador-private.h
View File

@ -1,75 +0,0 @@
/*
* network-inador-private.h
* This file is part of Network-Inador
*
* Copyright (C) 2024 - Félix Arreola Rodríguez
*
* Network-Inador is free software; 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 2 of the License, or
* (at your option) any later version.
*
* Network-Inador is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Network-Inador; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#ifndef __NETWORK_INADOR_PRIVATE_H__
#define __NETWORK_INADOR_PRIVATE_H__
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <netlink/socket.h>
#include <netlink/msg.h>
#include "network-inador.h"
#include "flist.h"
/* Para vigilar eventos */
typedef struct {
struct nl_sock * nl_sock;
unsigned int source;
} NetlinkEventPair;
/* La definición principal que engloba todo */
struct _NetworkInadorHandle {
struct NetworkInadorOps ops;
/* La verdadera información */
FList *interfaces;
FList *route_v4_tables;
FList *route_v6_tables;
FList *route_tables_names;
/* Entradas para el resolv conf */
FList *resolver_entries;
int resolver_inotify_fd;
int resolver_inotify_watch;
/* Estos sockets ejecutan comandos */
struct nl_sock * nl_sock_route;
//struct nl_sock * nl_sock_nl80211;
/* Estos sockets son de vigilancia de eventos */
int has_route_events;
NetlinkEventPair route_events;
/*NetlinkEventPair nl80211_scan;
NetlinkEventPair nl80211_scan_results;*/
/* El pipe de vigilancia especial de las rutas eliminadas */
int pipe_routes[2];
unsigned int source_pipe_routes;
};
#endif /* __NETWORK_INADOR_PRIVATE_H__ */

76
lib/network-inador.h
View File

@ -1,76 +0,0 @@
/*
* main.c
* This file is part of Network-inador
*
* Copyright (C) 2024 - Félix Arreola Rodríguez
*
* Network-inador is free software; 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 2 of the License, or
* (at your option) any later version.
*
* Network-inador is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Network-inador; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#ifndef __NETWORK_INADOR_H__
#define __NETWORK_INADOR_H__
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <sys/types.h>
#include <unistd.h>
#ifndef FALSE
#define FALSE 0
#endif
#ifndef TRUE
#define TRUE !FALSE
#endif
typedef struct _NetworkInadorHandle NetworkInadorHandle;
/* Función que define una lectura desde un FD */
typedef void (*NetworkInadorInputFunc) (void *, int, int);
typedef void (*NetworkInadorChildWatchFunc) (void *, pid_t, int);
struct NetworkInadorOps {
/* Vigilar FDs */
unsigned int (*input_add) (int fd, int cond, NetworkInadorInputFunc func, void *user_data);
void (*input_remove) (unsigned int);
/* Vigilar procesos */
unsigned int (*process_watch) (pid_t pid, NetworkInadorChildWatchFunc, void *user_data);
void (*process_unwatch) (unsigned int);
/* Ver si agregamos timers aquí */
};
NetworkInadorHandle * network_inador_init_handle (struct NetworkInadorOps *network_inador_ops);
void network_inador_destroy_handle (NetworkInadorHandle *handle);
void network_inador_setup_child_handler (NetworkInadorHandle *handle);
/* Funciones básicas de interfaces */
int interfaces_change_mac_address (NetworkInadorHandle *handle, int index, void *new_mac);
int interfaces_change_mtu (NetworkInadorHandle *handle, int index, uint32_t new_mtu);
int interfaces_change_set_up (NetworkInadorHandle *handle, int index);
int interfaces_change_set_down (NetworkInadorHandle *handle, int index);
int interfaces_change_name (NetworkInadorHandle *handle, int index, char * new_name);
/* Funciones básicas de dhcp */
int interfaces_dhcp_client_run (NetworkInadorHandle *handle, int index, int type, uint32_t flags);
int interfaces_dhcp_client_stop (NetworkInadorHandle *handle, int index);
#endif /* __NETWORK_INADOR_H__ */

11
lib/network-inador.pc.in
View File

@ -1,11 +0,0 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: Network Inador Library
Description: Network Inador Library main functions
Version: @VERSION@
Libs: -L${libdir} -lnetworkinador
Libs.private:
Cflags: -I${includedir}/libnetworkinador

166
lib/veth.c
View File

@ -1,166 +0,0 @@
/*
* veth.c
* This file is part of Network-inador
*
* Copyright (C) 2023 - Félix Arreola Rodríguez
*
* Network-inador is free software; 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 2 of the License, or
* (at your option) any later version.
*
* Network-inador is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Network-inador; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netlink/socket.h>
#include <netlink/msg.h>
#include <net/ethernet.h>
#include <net/if_arp.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <linux/veth.h>
#include "network-inador-private.h"
#include "interfaces.h"
int interfaces_veth_create (NetworkInadorHandle *handle, const char *link_name, const char *peer_name) {
struct nl_msg * msg;
struct ifinfomsg iface_hdr, peer_hdr;
struct nlattr *info, *data, *peer;
int ret, error, len;
const char *type = "veth";
if (link_name != NULL) {
/* Validar la longitud del nombre, por seguridad */
len = strlen (link_name) + 1;
if (len == 1) {
/* Nombre muy corto */
return -1;
}
if (len > IFNAMSIZ) {
/* Nombre muy largo */
return -1;
}
}
if (peer_name != NULL) {
/* Validar la longitud del nombre, por seguridad */
len = strlen (peer_name) + 1;
if (len == 1) {
/* Nombre muy corto */
return -1;
}
if (len > IFNAMSIZ) {
/* Nombre muy largo */
return -1;
}
}
memset (&iface_hdr, 0, sizeof (iface_hdr));
iface_hdr.ifi_family = AF_UNSPEC;
iface_hdr.ifi_index = 0;
msg = nlmsg_alloc_simple (RTM_NEWLINK, NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL);
ret = nlmsg_append (msg, &iface_hdr, sizeof (iface_hdr), NLMSG_ALIGNTO);
if (ret != 0) {
nlmsg_free (msg);
return -1;
}
/* Anexar el nombre, si es que especificaron uno */
if (link_name != NULL) {
ret = nla_put (msg, IFLA_IFNAME, strlen (link_name) + 1, link_name);
if (ret != 0) {
nlmsg_free (msg);
return -1;
}
}
info = nla_nest_start (msg, IFLA_LINKINFO);
if (info == NULL) {
nlmsg_free (msg);
return -1;
}
//ret = nla_put_string (msg, IFLA_INFO_KIND, type);
ret = nla_put (msg, IFLA_INFO_KIND, strlen (type), type);
if (ret != 0) {
nla_nest_end (msg, info);
nlmsg_free (msg);
return -1;
}
/* Ver cómo anexar IFLA_INFO_DATA */
data = nla_nest_start (msg, IFLA_INFO_DATA);
/* Vaciar la estructura del peer */
memset (&peer_hdr, 0, sizeof (peer_hdr));
peer_hdr.ifi_family = AF_UNSPEC;
peer_hdr.ifi_index = 0;
peer = nla_nest_start (msg, VETH_INFO_PEER);
nlmsg_append (msg, &peer_hdr, sizeof (peer_hdr), 0);
if (peer_name != NULL) {
ret = nla_put (msg, IFLA_IFNAME, strlen (peer_name) + 1, peer_name);
if (ret != 0) {
nlmsg_free (msg);
return -1;
}
}
nla_nest_end (msg, peer); /* Cerrar el VETH_INFO_PEER */
nla_nest_end (msg, data); /* Cerrar el IFLA_INFO_DATA */
nla_nest_end (msg, info); /* Cerrar el IFLA_LINKINFO */
nl_complete_msg (handle->nl_sock_route, msg);
ret = nl_send (handle->nl_sock_route, msg);
nlmsg_free (msg);
if (ret <= 0) {
return -1;
}
error = 0;
nl_socket_modify_cb (handle->nl_sock_route, NL_CB_VALID, NL_CB_CUSTOM, _interfaces_wait_ack_or_error, &error);
nl_socket_modify_cb (handle->nl_sock_route, NL_CB_INVALID, NL_CB_CUSTOM, _interfaces_wait_ack_or_error, &error);
nl_socket_modify_cb (handle->nl_sock_route, NL_CB_ACK, NL_CB_CUSTOM, _interfaces_wait_ack_or_error, &error);
nl_socket_modify_err_cb (handle->nl_sock_route, NL_CB_CUSTOM, _interfaces_wait_error, &error);
nl_recvmsgs_default (handle->nl_sock_route);
if (ret <= 0 || error < 0) {
return -1;
}
return 0;
}

29
lib/veth.h
View File

@ -1,29 +0,0 @@
/*
* veth.h
* This file is part of Network-inador
*
* Copyright (C) 2023 - Félix Arreola Rodríguez
*
* Network-inador is free software; 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 2 of the License, or
* (at your option) any later version.
*
* Network-inador is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Network-inador; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#ifndef __VETH_H__
#define __VETH_H__
int interfaces_veth_create (NetworkInadorHandle *handle, const char *link, const char *peer);
#endif /* __VETH_H__ */

24
lib/wireless_security.c
View File

@ -1,24 +0,0 @@
/*
* wireless_security.c
* This file is part of Network-inador
*
* Copyright (C) 2020 - Félix Arreola Rodríguez
*
* Network-inador is free software; 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 2 of the License, or
* (at your option) any later version.
*
* Network-inador is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Network-inador; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#include "wireless_security.h"

27
lib/wireless_security.h
View File

@ -1,27 +0,0 @@
/*
* wireless_security.h
* This file is part of Network-inador
*
* Copyright (C) 2020 - Félix Arreola Rodríguez
*
* Network-inador is free software; 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 2 of the License, or
* (at your option) any later version.
*
* Network-inador is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Network-inador; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#ifndef __WIRELESS_SECURITY_H__
#define __WIRELESS_SECURITY_H__
#endif /* __WIRELESS_SECURITY_H__ */

78
lib/wireless_struct.h
View File

@ -1,78 +0,0 @@
/*
* wireless_struct.h
* This file is part of Network-Inador
*
* Copyright (C) 2024 - Félix Arreola Rodríguez
*
* Network-Inador is free software; 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 2 of the License, or
* (at your option) any later version.
*
* Network-Inador is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Network-Inador; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#ifndef __WIRELESS_STRUCT_H__
#define __WIRELESS_STRUCT_H__
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <time.h>
#include <net/ethernet.h>
#include <netlink/socket.h>
#include <netlink/msg.h>
#include "flist.h"
#define SSID_MAX_LEN 32
typedef struct _WirelessBSS {
/** Number of counts without seeing this BSS */
unsigned int scan_miss_count;
/** Index of the last scan update */
unsigned int last_update_idx;
/** BSSID */
uint8_t bssid[ETHER_ADDR_LEN * 2 + 1];
/** HESSID */
//u8 hessid[ETHER_ADDR_LEN * 2 + 1];
/** SSID */
uint8_t ssid[SSID_MAX_LEN];
/** Length of SSID */
size_t ssid_len;
/** Frequency of the channel in MHz (e.g., 2412 = channel 1) */
int freq;
/** Capability information field in host byte order */
uint16_t caps;
/** Timestamp of last Beacon/Probe Response frame */
uint64_t tsf;
/** Time of the last update (i.e., Beacon or Probe Response RX) */
struct timespec last_update;
} WirelessBSS;
typedef struct _WirelessInfo {
int phy;
uint32_t *freqs;
int num_freqs;
uint32_t caps;
uint8_t can_scan;
uint8_t can_scan_ssid;
uint8_t supported;
unsigned int bss_update_idx;
FList *aps;
} WirelessInfo;
#endif /* __WIRELESS_STRUCT_H__ */

33
src/Makefile.am
View File

@ -1,17 +1,30 @@
# Automake file for NetworkInador
bin_PROGRAMS = network-inador
network_inador_SOURCES = main.c
# manager.c manager.h
network_inador_SOURCES = main.c \
common.h link-types.h \
dhcpc_defs.h \
struct_addr_union.h resolv_conf_defs.h \
netlink-events.c netlink-events.h \
interfaces.c interfaces.h \
ip-address.c ip-address.h \
bridge.c bridge.h \
manager.c manager.h \
dhcp_client.c dhcp_client.h \
routes.c routes.h \
resolv_manager.c resolv_manager.h \
resolv_conf_parser.c resolv_conf_parser.h \
wireless_if.c wireless_if.h \
wireless_bss.c wireless_bss.h \
utils.c utils.h
sbin_PROGRAMS = resolvconf
resolvconf_SOURCES = resolv_conf_helper.c \
../common/flist.c ../common/flist.h \
../common/resolv_conf_parser.c ../common/resolv_conf_parser.h \
../common/utils.c ../common/utils.h
resolvconf_CFLAGS = -I$(top_srcdir)/common -I$(top_srcdir)/lib -DSTAND_ALONE_RESOLV_CONF_HELPER_BUILD
resolvconf_LDADD =
#../common/libnicommon.a
struct_addr_union.h resolv_conf_defs.h \
resolv_conf_parser.c resolv_conf_parser.h \
utils.c utils.h \
glist.c glist.h
resolvconf_CFLAGS = -DSTAND_ALONE_RESOLV_CONF_HELPER_BUILD
libexec_PROGRAMS = ni-dhcp-helper
@ -21,8 +34,8 @@ ni_dhcp_helper_CFLAGS = $(AM_CFLAGS)
#network_inador_CPPFLAGS = -DGAMEDATA_DIR=\"$(gamedatadir)/\" -DLOCALEDIR=\"$(localedir)\" $(AM_CPPFLAGS)
network_inador_CPPFLAGS = -DLOCALEDIR=\"$(localedir)\" $(AM_CPPFLAGS)
network_inador_CFLAGS = -I$(top_srcdir)/lib $(GLIB_CFLAGS) $(LIBNL3_CFLAGS) $(LIBNLGEN3_CFLAGS) $(AM_CFLAGS)
network_inador_LDADD = $(GLIB_LIBS) $(LIBNL3_LIBS) $(LIBNLGEN3_LIBS) ../lib/libnetworkinador.la
network_inador_CFLAGS = $(GLIB_CFLAGS) $(LIBNL3_CFLAGS) $(LIBNLGEN3_CFLAGS) $(AM_CFLAGS)
network_inador_LDADD = $(GLIB_LIBS) $(LIBNL3_LIBS) $(LIBNLGEN3_LIBS)
LDADD = $(LIBINTL)
#SUBDIRS = client_test dhcpc

2
lib/bridge.c → src/bridge.c
View File

@ -35,7 +35,7 @@
#include <netinet/in.h>
#include <arpa/inet.h>
#include "network-inador-private.h"
#include "common.h"
#include "interfaces.h"
int interfaces_bridge_create (NetworkInadorHandle *handle, const char *name) {

0
lib/bridge.h → src/bridge.h
View File

248
src/common.h 100644
View File

@ -0,0 +1,248 @@
/*
* common.h
* This file is part of Network-inador
*
* Copyright (C) 2019, 2020 - Félix Arreola Rodríguez
*
* Network-inador is free software; 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 2 of the License, or
* (at your option) any later version.
*
* Network-inador is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Network-inador; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#ifndef __COMMON_H__
#define __COMMON_H__
#include <stdint.h>
#include <time.h>
#include <netinet/in.h>
#include <net/ethernet.h>
#include <linux/if.h>
#include <linux/if_addr.h>
#include <glib.h>
#include <gmodule.h>
#include "struct_addr_union.h"
#include "resolv_conf_defs.h"
#include "dhcpc_defs.h"
#ifndef FALSE
#define FALSE 0
#endif
#ifndef TRUE
#define TRUE !FALSE
#endif
#ifndef INFINITY_LIFE_TIME
#define INFINITY_LIFE_TIME 0xFFFFFFFFU
#endif
#define container_of(ptr, type, member) ({ \
const typeof( ((type *)0)->member ) *__mptr = (ptr); \
(type *)( (char *)__mptr - offsetof(type,member) );})
typedef struct _NetworkInadorHandle NetworkInadorHandle;
typedef struct _NetworkInadorManager NetworkInadorManager;
typedef struct _Interface Interface;
typedef struct _IPAddr {
sa_family_t family;
uint8_t prefix;
struct_addr local_addr;
struct_addr addr;
struct_addr brd_addr;
char label[256];
struct ifa_cacheinfo cacheinfo;
uint8_t is_p2p;
uint8_t has_brd;
uint8_t has_local;
uint32_t flags;
uint8_t scope;
Interface *iface;
} IPAddr;
#define SSID_MAX_LEN 32
typedef struct _WirelessBSS {
/** Number of counts without seeing this BSS */
unsigned int scan_miss_count;
/** Index of the last scan update */
unsigned int last_update_idx;
/** BSSID */
uint8_t bssid[ETHER_ADDR_LEN * 2 + 1];
/** HESSID */
//u8 hessid[ETHER_ADDR_LEN * 2 + 1];
/** SSID */
uint8_t ssid[SSID_MAX_LEN];
/** Length of SSID */
size_t ssid_len;
/** Frequency of the channel in MHz (e.g., 2412 = channel 1) */
int freq;
/** Capability information field in host byte order */
uint16_t caps;
/** Timestamp of last Beacon/Probe Response frame */
uint64_t tsf;
/** Time of the last update (i.e., Beacon or Probe Response RX) */
struct timespec last_update;
} WirelessBSS;
typedef struct _WirelessInfo {
int phy;
uint32_t *freqs;
int num_freqs;
uint32_t caps;
gboolean can_scan;
gboolean can_scan_ssid;
gboolean supported;
unsigned int bss_update_idx;
GList *aps;
} WirelessInfo;
struct _Interface {
NetworkInadorHandle *handle;
uint32_t index;
char name[IFNAMSIZ];
uint32_t link_type;
uint16_t arp_type;
unsigned char real_hw[ETHER_ADDR_LEN * 2 + 1];
/* Para las interfaces dentro de un bridge */
uint32_t master_index;
uint32_t mtu;
/* Para las interfaces vlan */
unsigned int vlan_parent;
/* Banderas estilo ioctl */
short flags;
int is_wireless;
char wireless_protocol[IFNAMSIZ];
/* Tipo */
char rtnl_type[IFNAMSIZ];
GList *address;
InterfaceDHCPClientInfo dhcpc;
/* Información wireless */
WirelessInfo *wireless;
};
/* Para los clientes y sus respectivos eventos */
typedef struct {
int fd;
/* Los eventos que quieren ser recibidos en este cliente */
uint32_t wanted_events;
guint source;
NetworkInadorManager *manager;
} ManagerClientInfo;
struct _NetworkInadorManager {
int socket;
guint source;
GList *connected_client_list;
NetworkInadorHandle *handle;
};
/* Para vigilar eventos */
typedef struct _netlink_event_pair {
struct nl_sock * nl_sock;
guint source;
} NetlinkEventPair;
typedef struct _RouteNH {
struct_addr gw;
uint32_t out_index;
uint8_t nh_weight;
uint8_t nh_flags;
} RouteNH;
/* La tabla de ruteo */
typedef struct _Route {
sa_family_t family; /* AF_INET, AF_INET6 */
uint8_t type; /* Unicast, local, broadcast, etc... */
uint32_t table;
struct_addr dest;
uint8_t prefix;
uint8_t tos;
uint8_t protocol;
uint8_t scope;
struct_addr prefsrc;
uint32_t priority;
/* Los brincos */
GList *nexthops;
/* Variable usada para determinar si debemos eliminar la ruta */
int for_delete;
} Route;
typedef struct _RouteTable {
uint32_t table;
char name[256];
int for_delete, was_new;
} RouteTable;
/* La definición principal que engloba todo */
struct _NetworkInadorHandle {
GList *interfaces;
GList *route_v4_tables;
GList *route_v6_tables;
GList *route_tables_names;
/* Entradas para el resolv conf */
GList *resolver_entries;
int resolver_inotify_fd;
int resolver_inotify_watch;
/* El manager */
NetworkInadorManager *manager;
/* Estos sockets ejecutan comandos */
struct nl_sock * nl_sock_route;
struct nl_sock * nl_sock_nl80211;
/* Estos sockets son de vigilancia de eventos */
NetlinkEventPair route_events;
NetlinkEventPair nl80211_scan;
NetlinkEventPair nl80211_scan_results;
/* El pipe de vigilancia especial de las rutas eliminadas */
int pipe_routes[2];
guint source_pipe_routes;
};
#endif /* __COMMON_H__ */

110
lib/dhcp_client.c → src/dhcp_client.c
View File

@ -34,20 +34,18 @@
#include <signal.h>
#include "interfaces.h"
#include "network-inador-private.h"
//#include "manager.h"
#include "common.h"
#include "manager.h"
#include "dhcp_client.h"
#include "resolv_manager.h"
#include "launch_process.h"
#include "network-inador-manager.h"
#include "resolv_manager.h"
static void interfaces_dhcp_clear_info (InterfaceDHCPClientInfo *dhcpc);
/*void interfaces_dhcp_client_ignore_kill (GPid pid, gint status, gpointer data) {
void interfaces_dhcp_client_ignore_kill (GPid pid, gint status, gpointer data) {
g_spawn_check_exit_status (status, NULL);
}*/
}
void interfaces_dhcp_prepare_args_for_isc_dhclient (char **argv, int size, char *iface_name, char *pid_file, size_t pid_file_len) {
snprintf (pid_file, pid_file_len, "/run/dhclient-%s.pid", iface_name);
@ -80,13 +78,12 @@ void interfaces_dhcp_prepare_args_for_busybox_udhcpc (char **argv, int size, cha
argv[9] = NULL;
}
void interfaces_dhcp_client_killed_cb (void *data, pid_t pid, int status) {
void interfaces_dhcp_client_killed_cb (GPid pid, gint status, gpointer data) {
Interface *iface = (Interface *) data;
NetworkInadorHandle *handle = iface->handle;
int ret;
int error = 0;
gboolean ret;
GError *error = NULL;
char *argv[20];
char pid_file[256];
gchar pid_file[256];
/* Preparar los argumentos */
if (iface->dhcpc.type == IFACE_ISC_DHCLIENT) {
@ -95,37 +92,21 @@ void interfaces_dhcp_client_killed_cb (void *data, pid_t pid, int status) {
interfaces_dhcp_prepare_args_for_busybox_udhcpc (argv, 20, iface->name, pid_file, sizeof (pid_file));
}
if (WIFEXITED (status)) {
if (g_spawn_check_exit_status (status, NULL)) {
/* Revisar si necesito algo */
}
/* Por limpieza, quitar la vigilancia del proceso */
if (handle->ops.process_unwatch != NULL) {
handle->ops.process_unwatch (iface->dhcpc.process_watch);
}
iface->dhcpc.process_watch = 0;
interfaces_dhcp_clear_info (&iface->dhcpc);
/* FIXME: ¿Debemos limpiar la información de DNS si no la movimos? */
resolv_manager_clear_dhcp_nameservers (iface->handle, iface);
/* Enviar actualización de estado aquí */
iface->dhcpc.dhcp_state = DHCP_CLIENT_KILLED;
//manager_send_event_dhcp_change (iface->handle, &iface->dhcpc);
manager_send_event_dhcp_change (iface->handle, &iface->dhcpc);
if (iface->dhcpc.type == IFACE_ISC_DHCLIENT || iface->dhcpc.type == IFACE_BUSYBOX_UDHCPC) {
if (iface->dhcpc.flags & DHCP_CLIENT_FLAG_AUTO_RESTART) {
/* Se cerró o mataron el proceso, reiniciar */
ret = launch_process (
"/",
argv,
NULL,
&iface->dhcpc.process_pid,
NULL,
NULL,
NULL,
&error);
/*ret = g_spawn_async_with_pipes (
ret = g_spawn_async_with_pipes (
"/",
argv,
NULL,
@ -136,25 +117,23 @@ void interfaces_dhcp_client_killed_cb (void *data, pid_t pid, int status) {
NULL,
NULL,
NULL,
&error);*/
&error);
if (ret == FALSE) {
printf ("Error dhcp: %s\n", strerror (error));
printf ("Error dhcp: %s\n", error->message);
g_error_free (error);
error = NULL;
iface->dhcpc.dhcp_state = DHCP_CLIENT_KILLED;
iface->dhcpc.process_watch = 0;
} else {
iface->dhcpc.dhcp_state = DHCP_CLIENT_SELECTING;
if (handle->ops.process_watch != NULL) {
iface->dhcpc.process_watch = handle->ops.process_watch (iface->dhcpc.process_pid, interfaces_dhcp_client_killed_cb, iface);
}
iface->dhcpc.process_watch = g_child_watch_add (iface->dhcpc.process_pid, interfaces_dhcp_client_killed_cb, iface);
}
} else {
/* En caso contrario, solo dejar la muerte escrita */
iface->dhcpc.dhcp_state = DHCP_CLIENT_KILLED;
if (handle->ops.process_unwatch != NULL) {
handle->ops.process_unwatch (iface->dhcpc.process_watch);
}
g_source_remove (iface->dhcpc.process_watch);
iface->dhcpc.process_watch = 0;
}
}
@ -175,10 +154,10 @@ static void interfaces_dhcp_clear_info (InterfaceDHCPClientInfo *dhcpc) {
int interfaces_dhcp_client_run (NetworkInadorHandle *handle, int index, int type, uint32_t flags) {
/* IFNAMSIZ */
Interface *iface;
int ret;
int error;
gboolean ret;
GError *error = NULL;
char *argv[20];
char pid_file[256];
gchar pid_file[256];
iface = _interfaces_locate_by_index (handle->interfaces, index);
@ -188,8 +167,6 @@ int interfaces_dhcp_client_run (NetworkInadorHandle *handle, int index, int type
return -1;
}
/* Revisar que tenga la función vigiladora de hijos muertos */
/* Preparar los argumentos */
if (type == IFACE_ISC_DHCLIENT) {
interfaces_dhcp_prepare_args_for_isc_dhclient (argv, 20, iface->name, pid_file, sizeof (pid_file));
@ -208,16 +185,7 @@ int interfaces_dhcp_client_run (NetworkInadorHandle *handle, int index, int type
interfaces_dhcp_clear_info (&iface->dhcpc);
ret = launch_process (
"/",
argv,
NULL,
&iface->dhcpc.process_pid,
NULL,
NULL,
NULL,
&error);
/* ret = g_spawn_async_with_pipes (
ret = g_spawn_async_with_pipes (
"/",
argv,
NULL,
@ -228,18 +196,13 @@ int interfaces_dhcp_client_run (NetworkInadorHandle *handle, int index, int type
NULL,
NULL,
NULL,
&error);*/
&error);
/*printf ("Por favor corre el siguiente comando DHCP:\n");
int g = 0;
while (argv[g] != NULL) {
printf ("%s ", argv[g]);
g++;
}
printf ("\n");
ret = TRUE;*/
if (ret == FALSE) {
printf ("Error dhcp: %s\n", strerror (error));
printf ("Error dhcp: %s\n", error->message);
g_error_free (error);
error = NULL;
return -1;
}
@ -248,11 +211,9 @@ int interfaces_dhcp_client_run (NetworkInadorHandle *handle, int index, int type
iface->dhcpc.type = type;
iface->dhcpc.flags = flags;
if (handle->ops.process_watch != NULL) {
iface->dhcpc.process_watch = handle->ops.process_watch (iface->dhcpc.process_pid, interfaces_dhcp_client_killed_cb, iface);
}
iface->dhcpc.process_watch = g_child_watch_add (iface->dhcpc.process_pid, interfaces_dhcp_client_killed_cb, iface);
//manager_send_event_dhcp_change (handle, &iface->dhcpc);
manager_send_event_dhcp_change (handle, &iface->dhcpc);
return 0;
}
@ -277,11 +238,9 @@ int interfaces_dhcp_client_stop (NetworkInadorHandle *handle, int index) {
/* Proceso, matar y reiniciar estado */
iface->dhcpc.flags &= (~DHCP_CLIENT_FLAG_AUTO_RESTART);
if (handle->ops.process_unwatch != NULL) {
handle->ops.process_unwatch (iface->dhcpc.process_watch);
}
g_source_remove (iface->dhcpc.process_watch);
iface->dhcpc.process_watch = 0;
// Si el proces muere, realmente no importa
g_child_watch_add (iface->dhcpc.process_pid, interfaces_dhcp_client_ignore_kill, NULL);
kill (iface->dhcpc.process_pid, SIGTERM);
iface->dhcpc.dhcp_state = DHCP_CLIENT_KILLED;
@ -293,7 +252,7 @@ int interfaces_dhcp_client_stop (NetworkInadorHandle *handle, int index) {
resolv_manager_clear_dhcp_nameservers (handle, iface);
/* Enviar actualización de estado aquí */
//manager_send_event_dhcp_change (handle, &iface->dhcpc);
manager_send_event_dhcp_change (handle, &iface->dhcpc);
}
return 0;
@ -386,7 +345,7 @@ void interfaces_dhcp_client_internal_feed_from_client (NetworkInadorHandle *hand
dns_changed = 1;
}
if (dns_changed && (iface->dhcpc.flags & DHCP_CLIENT_FLAG_DONT_ADD_DNS_INFO) == 0) {
if (dns_changed) {
resolv_manager_process_dhcp_nameservers (handle, iface);
}
@ -413,10 +372,9 @@ void interfaces_dhcp_client_internal_feed_from_client (NetworkInadorHandle *hand
/* Cuando entramos a SELECTING, debemos limpiar los DNS del resolv.conf */
interfaces_dhcp_clear_info (&iface->dhcpc);
/* FIXME: ¿Debemos limpiar la información DNS si no la movimos? */
resolv_manager_clear_dhcp_nameservers (handle, iface);
}
//manager_send_event_dhcp_change (handle, &iface->dhcpc);
manager_send_event_dhcp_change (handle, &iface->dhcpc);
}

5
lib/dhcp_client.h → src/dhcp_client.h
View File

@ -23,10 +23,7 @@
#ifndef __DHCP_CLIENT_H__
#define __DHCP_CLIENT_H__
#include <stdint.h>
#include "struct_addr_union.h"
#include "network-inador-private.h"
#include "common.h"
int interfaces_dhcp_client_run (NetworkInadorHandle *handle, int index, int type, uint32_t flags);
int interfaces_dhcp_client_stop (NetworkInadorHandle *handle, int index);

6
lib/dhcpc_defs.h → src/dhcpc_defs.h
View File

@ -24,7 +24,7 @@
#define __DHCPC_DEFS_H__
#include <stdint.h>
#include "flist.h"
#include <glib.h>
#include "struct_addr_union.h"
@ -59,8 +59,8 @@ typedef struct {
int dhcp_state;
/* Para vigilar el proceso */
pid_t process_pid;
unsigned int process_watch;
GPid process_pid;
guint process_watch;
/* La información obtenida desde el cliente */
struct_addr ip, broadcast;

694
common/flist.c → src/glist.c
View File

File diff suppressed because it is too large Load Diff

152
src/glist.h 100644
View File

@ -0,0 +1,152 @@
/* GLIB - Library of useful routines for C programming
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
/*
* Modified by the GLib Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GLib Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GLib at ftp://ftp.gtk.org/pub/gtk/.
*/
#ifndef __G_LIST_H__
#define __G_LIST_H__
#define G_GNUC_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
typedef void * gpointer;
typedef const void * gconstpointer;
typedef void (*GDestroyNotify) (gpointer data);
typedef void (*GFunc) (gpointer data, gpointer user_data);
typedef int (*GCompareDataFunc) (gconstpointer a, gconstpointer b, gpointer user_data);
typedef int (*GCompareFunc) (gconstpointer a, gconstpointer b);
typedef gpointer (*GCopyFunc) (gconstpointer src, gpointer data);
typedef struct _GList GList;
struct _GList
{
gpointer data;
GList *next;
GList *prev;
};
/* Doubly linked lists
*/
GList* g_list_alloc (void) G_GNUC_WARN_UNUSED_RESULT;
void g_list_free (GList *list);
void g_list_free_1 (GList *list);
#define g_list_free1 g_list_free_1
void g_list_free_full (GList *list,
GDestroyNotify free_func);
GList* g_list_append (GList *list,
gpointer data) G_GNUC_WARN_UNUSED_RESULT;
GList* g_list_prepend (GList *list,
gpointer data) G_GNUC_WARN_UNUSED_RESULT;
GList* g_list_insert (GList *list,
gpointer data,
int position) G_GNUC_WARN_UNUSED_RESULT;
GList* g_list_insert_sorted (GList *list,
gpointer data,
GCompareFunc func) G_GNUC_WARN_UNUSED_RESULT;
GList* g_list_insert_sorted_with_data (GList *list,
gpointer data,
GCompareDataFunc func,
gpointer user_data) G_GNUC_WARN_UNUSED_RESULT;
GList* g_list_insert_before (GList *list,
GList *sibling,
gpointer data) G_GNUC_WARN_UNUSED_RESULT;
GList* g_list_concat (GList *list1,
GList *list2) G_GNUC_WARN_UNUSED_RESULT;
GList* g_list_remove (GList *list,
gconstpointer data) G_GNUC_WARN_UNUSED_RESULT;
GList* g_list_remove_all (GList *list,
gconstpointer data) G_GNUC_WARN_UNUSED_RESULT;
GList* g_list_remove_link (GList *list,
GList *llink) G_GNUC_WARN_UNUSED_RESULT;
GList* g_list_delete_link (GList *list,
GList *link_) G_GNUC_WARN_UNUSED_RESULT;
GList* g_list_reverse (GList *list) G_GNUC_WARN_UNUSED_RESULT;
GList* g_list_copy (GList *list) G_GNUC_WARN_UNUSED_RESULT;
GList* g_list_copy_deep (GList *list,
GCopyFunc func,
gpointer user_data) G_GNUC_WARN_UNUSED_RESULT;
GList* g_list_nth (GList *list,
unsigned int n);
GList* g_list_nth_prev (GList *list,
unsigned int n);
GList* g_list_find (GList *list,
gconstpointer data);
GList* g_list_find_custom (GList *list,
gconstpointer data,
GCompareFunc func);
int g_list_position (GList *list,
GList *llink);
int g_list_index (GList *list,
gconstpointer data);
GList* g_list_last (GList *list);
GList* g_list_first (GList *list);
unsigned int g_list_length (GList *list);
void g_list_foreach (GList *list,
GFunc func,
gpointer user_data);
GList* g_list_sort (GList *list,
GCompareFunc compare_func) G_GNUC_WARN_UNUSED_RESULT;
GList* g_list_sort_with_data (GList *list,
GCompareDataFunc compare_func,
gpointer user_data) G_GNUC_WARN_UNUSED_RESULT;
gpointer g_list_nth_data (GList *list,
unsigned int n);
#define g_list_previous(list) ((list) ? (((GList *)(list))->prev) : NULL)
#define g_list_next(list) ((list) ? (((GList *)(list))->next) : NULL)
#endif /* __G_LIST_H__ */

194
lib/interfaces.c → src/interfaces.c
View File

@ -27,16 +27,16 @@
#include <linux/if_arp.h>
#include <stdarg.h>
#include <gmodule.h>
#include "network-inador-private.h"
#include "common.h"
#include "interfaces.h"
#include "routes.h"
#include "ip-address.h"
#include "wireless_if.h"
//#include "manager.h"
#include "manager.h"
#include "network-inador-link-types.h"
#include "link-types.h"
static int _interfaces_receive_message_interface (struct nl_msg *msg, void *arg, int first_time);
@ -117,7 +117,7 @@ static int _interfaces_receive_message_interface (struct nl_msg *msg, void *arg,
memset (iface, 0, sizeof (Interface));
iface->handle = handle;
handle->interfaces = f_list_append (handle->interfaces, iface);
handle->interfaces = g_list_append (handle->interfaces, iface);
was_new = 1;
}
@ -135,9 +135,9 @@ static int _interfaces_receive_message_interface (struct nl_msg *msg, void *arg,
}
}
//printf ("Interface %d agregada a la interfaz %d (bridge)\n", iface->index, iface->master_index);
printf ("Interface %d agregada a la interfaz %d (bridge)\n", iface->index, iface->master_index);
was_update = 1;
//manager_send_event_interface_update (handle, iface);
manager_send_event_interface_update (handle, iface);
return NL_SKIP;
}
@ -216,59 +216,7 @@ static int _interfaces_receive_message_interface (struct nl_msg *msg, void *arg,
u32data = nla_get_u32 (attr);
iface->vlan_parent = u32data;
//printf ("Interface %d: tiene como padre a %d\n", iface->index, iface->vlan_parent);
break;
case IFLA_PROTINFO:
printf ("OoOoO Interface %i tiene IFLA_PROTINFO oOoOo: %i\n", iface->index, IFLA_PROTINFO);
break;
case IFLA_AF_SPEC:
{
struct nlattr *sub_family;
int sub_family_len;
sub_family = nla_data (attr);
remaining = nla_len (attr);
while (remaining > sizeof (sub_family)) {
sub_family_len = sub_family->nla_len;
if (sub_family_len > remaining) {
printf ("Los sub atributos se acabaron prematuramente\n");
break;
}
printf ("Interface %d, IFLA_AF_SPEC, sub attributo type: %i, tamaño: %i\n", iface->index, sub_family->nla_type, sub_family_len);
if (sub_family->nla_type == AF_INET6) {
struct nlattr *sub_attr;
int sub_remaining;
nla_for_each_nested(sub_attr, sub_family, sub_remaining) {
printf ("\tIFLA_AF_SPEC, family: %i attr: %i, len: %i\n", sub_family->nla_type, nla_type (sub_attr), sub_attr->nla_len);
unsigned char *ttt;
switch (nla_type (sub_attr)) {
case IFLA_INET6_FLAGS:
iface->inet6_data.i6_flags = nla_get_u32 (sub_attr);
break;
case IFLA_INET6_CONF:
ttt = nla_data (sub_attr);
printf ("Size of data: %i, sizeof struct: %i\n", nla_len (sub_attr), sizeof (iface->inet6_data.i6_conf));
memcpy (iface->inet6_data.i6_conf, ttt, sizeof (iface->inet6_data.i6_conf));
break;
case IFLA_INET6_CACHEINFO:
memcpy (&iface->inet6_data.i6_cacheinfo, nla_data (sub_attr), sizeof (iface->inet6_data.i6_cacheinfo));
break;
case IFLA_INET6_ADDR_GEN_MODE:
iface->inet6_data.i6_addr_gen_mode = nla_get_u8 (sub_attr);
break;
}
}
}
/* Avanzar a la siguiente familia presente */
remaining -= RTA_ALIGN (sub_family_len);
sub_family = (struct nlattr *) (((char *) sub_family) + RTA_ALIGN (sub_family_len));
}
}
break;
printf ("Interface %d: tiene como padre a %d\n", iface->index, iface->vlan_parent);
/*default:
printf ("RTA Attribute \"%hu\" no procesado\n", nla_type (attr));*/
}
@ -281,23 +229,23 @@ static int _interfaces_receive_message_interface (struct nl_msg *msg, void *arg,
}
if (was_new) {
//printf ("+++++ Interfaz nueva creada: %s\n", iface->name);
//wireless_interface_check (handle, iface);
printf ("+++++ Interfaz nueva creada: %s\n", iface->name);
wireless_interface_check (handle, iface);
iface->link_type = interfaces_check_link_type (iface);
//manager_send_event_interface_add (handle, iface);
manager_send_event_interface_add (handle, iface);
} else if (was_update) {
//manager_send_event_interface_update (handle, iface);
manager_send_event_interface_update (handle, iface);
}
return NL_SKIP;
}
Interface * _interfaces_locate_by_index (FList *list, int index) {
Interface * _interfaces_locate_by_index (GList *list, int index) {
Interface *iface;
FList *g;
GList *g;
for (g = list; g != NULL; g = g->next) {
iface = (Interface *) g->data;
@ -310,10 +258,10 @@ Interface * _interfaces_locate_by_index (FList *list, int index) {
return NULL;
}
Interface * _interfaces_locate_by_name (FList *list, const char *name) {
Interface * _interfaces_locate_by_name (GList *list, const char *name) {
Interface *iface;
FList *g;
GList *g;
for (g = list; g != NULL; g = g->next) {
iface = (Interface *) g->data;
@ -386,23 +334,23 @@ int interface_receive_message_dellink (struct nl_msg *msg, void *arg) {
}
}
//printf ("Interface %d se sacó de su bridge\n", iface->index);
printf ("Interface %d se sacó de su bridge\n", iface->index);
/* Generar EVENTO AQUI */
//manager_send_event_interface_update (handle, iface);
manager_send_event_interface_update (handle, iface);
return NL_SKIP;
}
route_ask_delayed_delroute (handle);
//printf ("----- Interfaz eliminada: %s\n", iface->name);
printf ("----- Interfaz eliminada: %s\n", iface->name);
handle->interfaces = f_list_remove (handle->interfaces, iface);
handle->interfaces = g_list_remove (handle->interfaces, iface);
/* Antes de eliminar la interfaz, eliminar la lista ligada de todas las direcciones IP */
f_list_free_full (iface->address, free);
g_list_free_full (iface->address, free);
//manager_send_event_interface_del (handle, iface->index);
manager_send_event_interface_del (handle, iface->index);
free (iface);
}
@ -417,7 +365,7 @@ int interfaces_change_mac_address (NetworkInadorHandle *handle, int index, void
iface = _interfaces_locate_by_index (handle->interfaces, index);
if (iface == NULL) {
//printf ("Error, solicitaron operación sobre interfaz que no existe\n");
printf ("Error, solicitaron operación sobre interfaz que no existe\n");
return -1;
}
@ -479,7 +427,7 @@ int interfaces_change_mtu (NetworkInadorHandle *handle, int index, uint32_t new_
iface = _interfaces_locate_by_index (handle->interfaces, index);
if (iface == NULL) {
//printf ("Error, solicitaron operación sobre interfaz que no existe\n");
printf ("Error, solicitaron operación sobre interfaz que no existe\n");
return -1;
}
@ -670,93 +618,6 @@ int interfaces_change_name (NetworkInadorHandle *handle, int index, char * new_n
return 0;
}
#if 0
int interfaces_set_sysctl_ipv6_params (NetworkInadorHandle *handle, int index, int param, ...) {
uint32_t new_sysctl[DEVCONF_MAX];
Interface *iface;
va_list va_list_params;
uint32_t value;
struct nl_msg * msg, *msg2, *msg3;
struct ifinfomsg iface_hdr;
int ret, error;
iface = _interfaces_locate_by_index (handle->interfaces, index);
if (iface == NULL) {
printf ("Error, solicitaron operación sobre interfaz que no existe\n");
return -1;
}
/* Copiar los sysctl previos para preservarlos */
memcpy (new_sysctl, iface->inet6_data.i6_conf, sizeof (new_sysctl));
va_start (va_list_params, param);
while (param != -1) {
value = va_arg (va_list_params, uint32_t);
if (param < DEVCONF_MAX) {
new_sysctl[param] = value;
}
param = va_arg (va_list_params, int);
}
va_end (va_list_params);
/* Preparar el mensaje de configurar la interfaz */
memset (&iface_hdr, 0, sizeof (iface_hdr));
#define LINK_ATTR_AF_SPEC (1 << 27)
iface_hdr.ifi_family = AF_UNSPEC;
iface_hdr.ifi_index = iface->index;
iface_hdr.ifi_change = LINK_ATTR_AF_SPEC;
msg = nlmsg_alloc_simple (RTM_SETLINK, NLM_F_REQUEST);
ret = nlmsg_append (msg, &iface_hdr, sizeof (iface_hdr), NLMSG_ALIGNTO);
if (ret != 0) {
nlmsg_free (msg);
return -1;
}
/* FIXME: Aquí el nesting doble o triple */
msg2 = nlmsg_alloc_simple (RTM_NEWLINK, NLM_F_REQUEST);
msg3 = nlmsg_alloc_simple (RTM_NEWLINK, NLM_F_REQUEST);
nla_put (msg3, IFLA_INET6_CONF, sizeof (new_sysctl), new_sysctl);
nla_put_nested (msg2, AF_INET6 | NLA_F_NESTED, msg3);
nla_put_nested (msg, IFLA_AF_SPEC | NLA_F_NESTED, msg2);
nl_complete_msg (handle->nl_sock_route, msg);
ret = nl_send (handle->nl_sock_route, msg);
nlmsg_free (msg);
nlmsg_free (msg2);
nlmsg_free (msg3);
if (ret <= 0) {
return -1;
}
error = 0;
nl_socket_modify_cb (handle->nl_sock_route, NL_CB_VALID, NL_CB_CUSTOM, _interfaces_wait_ack_or_error, &error);
nl_socket_modify_cb (handle->nl_sock_route, NL_CB_INVALID, NL_CB_CUSTOM, _interfaces_wait_ack_or_error, &error);
nl_socket_modify_cb (handle->nl_sock_route, NL_CB_ACK, NL_CB_CUSTOM, _interfaces_wait_ack_or_error, &error);
nl_socket_modify_err_cb (handle->nl_sock_route, NL_CB_CUSTOM, _interfaces_wait_error, &error);
nl_recvmsgs_default (handle->nl_sock_route);
if (ret <= 0 || error < 0) {
return -1;
}
return 0;
}
#endif
void interfaces_init (NetworkInadorHandle *handle) {
/* Si es la primera vez que nos llaman, descargar una primera lista de interfaces */
struct nl_msg * msg;
@ -786,18 +647,17 @@ void interfaces_init (NetworkInadorHandle *handle) {
}
void interfaces_clean_up (NetworkInadorHandle *handle) {
FList *g;
GList *g;
Interface *iface;
for (g = handle->interfaces; g != NULL; g = g->next) {
iface = (Interface *) g->data;
/* Antes de eliminar la interfaz, eliminar la lista ligada de todas las direcciones IP */
f_list_free_full (iface->address, free);
g_list_free_full (iface->address, free);
iface->address = NULL;
}
f_list_free_full (handle->interfaces, free);
g_list_free_full (handle->interfaces, free);
handle->interfaces = NULL;
}

63
lib/interfaces.h → src/interfaces.h
View File

@ -25,63 +25,8 @@
#include <netlink/socket.h>
#include <netlink/msg.h>
#include <stdarg.h>
#include <stdint.h>
#include <linux/ipv6.h>
#include <linux/if_link.h>
#include "flist.h"
#include "network-inador-private.h"
#include "dhcpc_defs.h"
#include "wireless_struct.h"
/* Información extra de IPv6 para la interfaz */
struct inet6_data {
uint32_t i6_flags;
struct ifla_cacheinfo i6_cacheinfo;
uint32_t i6_conf[DEVCONF_MAX];
uint8_t i6_addr_gen_mode;
};
typedef struct {
NetworkInadorHandle *handle;
uint32_t index;
char name[IFNAMSIZ];
uint32_t link_type;
uint16_t arp_type;
unsigned char real_hw[ETHER_ADDR_LEN * 2 + 1];
/* Para las interfaces dentro de un bridge */
uint32_t master_index;
uint32_t mtu;
/* Para las interfaces vlan */
unsigned int vlan_parent;
/* Banderas estilo ioctl */
short flags;
int is_wireless;
char wireless_protocol[IFNAMSIZ];
/* Tipo */
char rtnl_type[IFNAMSIZ];
/* Para los parámetros de IPv4 e IPv6 */
struct inet6_data inet6_data;
/* La lista de direcciones IP, ambas */
FList *address;
InterfaceDHCPClientInfo dhcpc;
/* Información wireless */
WirelessInfo *wireless;
} Interface;
#include "common.h"
void interfaces_init (NetworkInadorHandle *handle);
int interface_receive_message_newlink (struct nl_msg *msg, void *arg);
@ -90,8 +35,8 @@ int interface_receive_message_dellink (struct nl_msg *msg, void *arg);
int _interfaces_wait_ack_or_error (struct nl_msg *msg, void *arg);
int _interfaces_wait_error (struct sockaddr_nl *nla, struct nlmsgerr *l_err, void *arg);
Interface * _interfaces_locate_by_index (FList *list, int index);
Interface * _interfaces_locate_by_name (FList *list, const char *name);
Interface * _interfaces_locate_by_index (GList *list, int index);
Interface * _interfaces_locate_by_name (GList *list, const char *name);
int interfaces_change_mac_address (NetworkInadorHandle *handle, int index, void *new_mac);
int interfaces_change_mtu (NetworkInadorHandle *handle, int index, uint32_t new_mtu);
@ -99,8 +44,6 @@ int interfaces_change_set_up (NetworkInadorHandle *handle, int index);
int interfaces_change_set_down (NetworkInadorHandle *handle, int index);
int interfaces_change_name (NetworkInadorHandle *handle, int index, char * new_name);
//int interfaces_set_sysctl_ipv6_params (NetworkInadorHandle *handle, int index, int param, ...);
void interfaces_clean_up (NetworkInadorHandle *handle);
#endif

32
lib/ip-address.c → src/ip-address.c
View File

@ -29,14 +29,16 @@
#include <linux/if_addr.h>
#include <arpa/inet.h>
#include "network-inador-private.h"
#include <gmodule.h>
#include "common.h"
#include "ip-address.h"
#include "interfaces.h"
//#include "manager.h"
#include "manager.h"
#include "routes.h"
IPAddr *_ip_address_search_addr (Interface *iface, sa_family_t family, void *addr, uint32_t prefix, void *local_addr) {
FList *g;
GList *g;
IPAddr *ip_addr;
int family_size = 0;
@ -103,7 +105,7 @@ int ip_address_receive_message_newaddr (struct nl_msg *msg, void *arg) {
return NL_SKIP;
}
//printf ("-> New addr\n");
printf ("-> New addr\n");
new_flags = addr_msg->ifa_flags;
@ -124,7 +126,7 @@ int ip_address_receive_message_newaddr (struct nl_msg *msg, void *arg) {
cacheinfo.tstamp = 0;
nlmsg_for_each_attr(attr, reply, sizeof (struct ifaddrmsg), remaining) {
//printf ("-> new addr type attr: %i\n", nla_type (attr));
printf ("-> new addr type attr: %i\n", nla_type (attr));
switch (nla_type (attr)) {
case IFA_FLAGS:
new_flags = nla_get_u32 (attr);
@ -161,7 +163,7 @@ int ip_address_receive_message_newaddr (struct nl_msg *msg, void *arg) {
ip_addr = malloc (sizeof (IPAddr));
memset (ip_addr, 0, sizeof (*ip_addr));
iface->address = f_list_append (iface->address, ip_addr);
iface->address = g_list_append (iface->address, ip_addr);
ip_addr->family = addr_msg->ifa_family;
memcpy (&ip_addr->addr, &addr, family_size);
@ -203,7 +205,7 @@ int ip_address_receive_message_newaddr (struct nl_msg *msg, void *arg) {
}
if (was_new) {
//manager_send_event_ip_add (handle, ip_addr);
manager_send_event_ip_add (handle, ip_addr);
} else {
/* En caso contrario, enviar una actualización de IP */
}
@ -258,9 +260,9 @@ int ip_address_receive_message_deladdr (struct nl_msg *msg, void *arg) {
family_size = sizeof (struct in6_addr);
}
//printf ("DEL MSG\n");
printf ("DEL MSG\n");
nlmsg_for_each_attr(attr, reply, sizeof (struct ifaddrmsg), remaining) {
//printf ("-> del addr type attr: %i\n", nla_type (attr));
printf ("-> del addr type attr: %i\n", nla_type (attr));
switch (nla_type (attr)) {
case IFA_ADDRESS:
memcpy (&addr, nla_data (attr), nla_len (attr));
@ -277,7 +279,7 @@ int ip_address_receive_message_deladdr (struct nl_msg *msg, void *arg) {
ip_addr = _ip_address_search_addr (iface, family, &addr, addr_msg->ifa_prefixlen, (has_local ? &local_addr : NULL));
if (ip_addr == NULL) {
//printf ("IP no encontrada\n");
printf ("IP no encontrada\n");
return NL_SKIP;
}
@ -286,10 +288,10 @@ int ip_address_receive_message_deladdr (struct nl_msg *msg, void *arg) {
printf ("Dirección IP - %s/%d sobre interfaz: %d, scope: %d, flags: %u\n", buffer, ip_addr->prefix, iface->index, (unsigned int) ip_addr->scope, ip_addr->flags);
/* Eliminar de la lista ligada */
iface->address = f_list_remove (iface->address, ip_addr);
iface->address = g_list_remove (iface->address, ip_addr);
/* Notificar del evento */
//manager_send_event_ip_del (handle, ip_addr);
manager_send_event_ip_del (handle, ip_addr);
free (ip_addr);
@ -327,7 +329,6 @@ int ip_address_add_ip (NetworkInadorHandle *handle, int index, IPAddr *ip_addr)
Interface *iface;
int family_size = 0;
/* TODO: Si no tenemos los route events, podríamos ejecutar una lectura de interfaces para refrescar la lista */
iface = _interfaces_locate_by_index (handle->interfaces, index);
if (iface == NULL) {
@ -409,10 +410,9 @@ int ip_address_del_ip (NetworkInadorHandle *handle, int index, IPAddr *ip_addr)
struct ifaddrmsg addr_hdr;
int ret, error;
Interface *iface;
FList *addr_pos;
GList *addr_pos;
int family_size = 0;
/* TODO: Si no tenemos los eventos, podemos ejecutar una lectura de interfaces para refrescar la información */
iface = _interfaces_locate_by_index (handle->interfaces, index);
if (iface == NULL) {
@ -421,7 +421,7 @@ int ip_address_del_ip (NetworkInadorHandle *handle, int index, IPAddr *ip_addr)
return -1;
}
addr_pos = f_list_find (iface->address, ip_addr);
addr_pos = g_list_find (iface->address, ip_addr);
if (addr_pos == NULL) {
printf ("Error, la dirección solicitada no pertenece a la interfaz\n");

30
lib/ip-address.h → src/ip-address.h
View File

@ -26,35 +26,7 @@
#include <netlink/socket.h>
#include <netlink/msg.h>
#include "network-inador-private.h"
#include "interfaces.h"
#include "struct_addr_union.h"
#ifndef INFINITY_LIFE_TIME
#define INFINITY_LIFE_TIME 0xFFFFFFFFU
#endif
typedef struct {
sa_family_t family;
uint8_t prefix;
struct_addr local_addr;
struct_addr addr;
struct_addr brd_addr;
char label[256];
struct ifa_cacheinfo cacheinfo;
uint8_t is_p2p;
uint8_t has_brd;
uint8_t has_local;
uint32_t flags;
uint8_t scope;
Interface *iface;
} IPAddr;
#include "common.h"
int ip_address_receive_message_newaddr (struct nl_msg *msg, void *arg);
int ip_address_receive_message_deladdr (struct nl_msg *msg, void *arg);

0
lib/network-inador-link-types.h → src/link-types.h
View File

184
src/main.c
View File

@ -38,11 +38,28 @@
#include <fcntl.h>
#include "network-inador.h"
#include "common.h"
#include "manager.h"
#include "interfaces.h"
#include "netlink-events.h"
#include "ip-address.h"
#include "bridge.h"
#include "dhcp_client.h"
#include "routes.h"
#include "resolv_manager.h"
/* Usados para salir en caso de una señal */
static int sigterm_pipe_fds[2] = { -1, -1 };
static void _init_handle (NetworkInadorHandle *handle) {
assert (handle != NULL);
memset (handle, 0, sizeof (NetworkInadorHandle));
handle->interfaces = NULL;
handle->pipe_routes[0] = -1;
handle->pipe_routes[1] = -1;
}
static void _sigterm_handler (int signum) {
//fprintf (stderr, "SIGTERM SIGINT Handler\n");
if (sigterm_pipe_fds[1] >= 0) {
@ -97,163 +114,54 @@ static void _main_setup_signal (void *loop) {
}
}
typedef struct _NetworkInadorGLibIOClosure {
NetworkInadorInputFunc function;
guint result;
gpointer data;
} NetworkInadorGLibIOClosure;
static void glib_io_destroy (gpointer data) {
g_free (data);
}
gboolean glib_io_invoke (GIOChannel *source, GIOCondition condition, gpointer data) {
NetworkInadorGLibIOClosure *closure = data;
int cond = 0;
if (condition & G_IO_IN) {
cond |= POLLIN;
}
if (condition & G_IO_OUT) {
cond |= POLLOUT;
}
closure->function (closure->data, g_io_channel_unix_get_fd (source), cond);
return TRUE;
}
unsigned int glib_input_add (int fd, int cond, NetworkInadorInputFunc func, void *user_data) {
GIOChannel *channel;
NetworkInadorGLibIOClosure *closure = g_new0 (NetworkInadorGLibIOClosure, 1);
GIOCondition gcond = 0;
closure->function = func;
closure->data = user_data;
if (cond == POLLIN) {
gcond = G_IO_IN | G_IO_PRI | G_IO_HUP | G_IO_ERR;
} else if (cond == POLLOUT) {
gcond = G_IO_OUT | G_IO_PRI | G_IO_HUP | G_IO_ERR;
}
channel = g_io_channel_unix_new (fd);
closure->result = g_io_add_watch_full (channel, G_PRIORITY_DEFAULT, cond, glib_io_invoke, closure, glib_io_destroy);
g_io_channel_unref(channel);
return closure->result;
}
struct NetworkInadorOps network_ops = {
.input_add = glib_input_add,
.input_remove = g_source_remove,
};
int main (int argc, char *argv[]) {
NetworkInadorHandle *handle;
NetworkInadorHandle handle;
GMainLoop *loop = NULL;
struct nl_sock * sock_req;
#if !defined(GLIB_VERSION_2_36)
g_type_init ();
#endif
handle = network_inador_init_handle (&network_ops);
_init_handle (&handle);
/* Dejar que la librería maneje los procesos hijos muertos */
network_inador_setup_child_handler (handle);
/* Crear el socket de peticiones */
sock_req = nl_socket_alloc ();
if (nl_connect (sock_req, NETLINK_ROUTE) != 0) {
perror ("Falló conectar netlink socket\n");
return -1;
}
handle.nl_sock_route = sock_req;
/* Crear el socket que escucha eventos */
netlink_events_setup (&handle);
loop = g_main_loop_new (NULL, FALSE);
_main_setup_signal (loop);
interfaces_dhcp_client_run (handle, 3, 1, 1);
/*IPAddr addr;
inet_pton (AF_INET, "192.19.5.6", &addr.sin_addr);
addr.family = AF_INET;
addr.prefix = 25;
addr.flags = 128;
addr.scope = 0;
/* Inicializar las interfaces (y las direcciones IP) */
interfaces_init (&handle);
ip_address_add_ip (&handle, 3, &addr);*/
/* Inicializar las rutas */
routes_init (&handle);
/*GList *g;
Interface *x;
for (g = handle.interfaces; g != NULL; g = g->next) {
x = (Interface *) g->data;
/* Inicializar el resolv.conf */
resolv_manager_init (&handle);
if (x->index == 2 && x->address != NULL) {
ip_address_del_ip (&handle, x->index, x->address->data);
}
}*/
//interfaces_bridge_create (&handle, "br0");
//interfaces_bridge_set_master_interface (&handle, 4, 5);
//interfaces_bridge_remove_master_interface (&handle, 5);
//interfaces_bridge_delete (&handle, 4);
//interfaces_dhcp_client_run (&handle, 2, IFACE_BUSYBOX_UDHCPC, DHCP_CLIENT_FLAG_AUTO_RESTART);
#if 0
// Prueba de agregar ruta
Route route;
GList nhl1, nhl2;
RouteNH nh1, nh2;
memset (&route, 0, sizeof (route));
route.family = AF_INET;
route.type = RTN_UNICAST;
route.table = 0;
inet_pton (AF_INET, "10.8.9.0", &route.dest);
route.prefix = 24;
route.protocol = RTPROT_STATIC;
route.tos = 0;
route.priority = 400;
route.nexthops = &nhl1;
memset (&nh1, 0, sizeof (nh1));
memset (&nh2, 0, sizeof (nh2));
nhl1.prev = NULL;
nhl1.next = &nhl2;
nhl2.prev = &nhl1;
nhl2.next = NULL;
nhl1.data = &nh1;
nhl2.data = &nh2;
inet_pton (AF_INET, "172.22.201.1", &nh1.gw);
inet_pton (AF_INET, "172.22.201.2", &nh2.gw);
nh1.out_index = 0;
nh2.out_index = 0;
nh1.nh_weight = 4;
nh2.nh_weight = 9;
routes_add (&handle, &route);
#endif
#if 0
// Prueba de eliminar una ruta
Route route;
memset (&route, 0, sizeof (route));
route.family = AF_INET;
route.table = 0;
inet_pton (AF_INET, "172.18.5.0", &route.dest);
route.prefix = 24;
route.tos = 0x18;
routes_del (&handle, &route);
interfaces_veth_create (&handle, "abc", "def");
#endif
/*interfaces_change_set_down (&handle, 4);
int ret = interfaces_set_sysctl_ipv6_params (&handle, 4, DEVCONF_DISABLE_IPV6, (uint32_t) 1, -1);
printf ("Ret sel sysctl: %i\n", ret);
interfaces_change_set_up (&handle, 4);*/
manager_init (&handle);
g_main_loop_run (loop);
network_inador_destroy_handle (handle);
/* Detener la llegada de eventos */
netlink_events_clear (&handle);
g_main_loop_unref (loop);
routes_clean_up (&handle);
interfaces_clean_up (&handle);
// nl_socket_free???
return 0;
}

2
src/manager.c
View File

@ -39,7 +39,7 @@
#include <linux/if_addr.h>
#include <sys/stat.h>
#include "network-inador-private.h"
#include "common.h"
#include "interfaces.h"
#include "ip-address.h"
#include "routes.h"

160
src/netlink-events.c 100644
View File

@ -0,0 +1,160 @@
/*
* netlink-events.c
* This file is part of Network-inador
*
* Copyright (C) 2019, 2020 - Félix Arreola Rodríguez
*
* Network-inador is free software; 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 2 of the License, or
* (at your option) any later version.
*
* Network-inador is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Network-inador; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
#include <stdio.h>
#include <unistd.h>
#include <netlink/socket.h>
#include <netlink/msg.h>
#include <glib.h>
#include <linux/nl80211.h>
#include <fcntl.h>
#include "common.h"
#include "interfaces.h"
#include "ip-address.h"
#include "routes.h"
static int _netlink_events_route_dispatcher (struct nl_msg *msg, void *arg) {
struct nlmsghdr *reply;
reply = nlmsg_hdr (msg);
switch (reply->nlmsg_type) {
case RTM_NEWLINK:
return interface_receive_message_newlink (msg, arg);
break;
case RTM_DELLINK:
return interface_receive_message_dellink (msg, arg);
break;
case RTM_NEWADDR:
return ip_address_receive_message_newaddr (msg, arg);
break;
case RTM_DELADDR:
return ip_address_receive_message_deladdr (msg, arg);
break;
case RTM_NEWROUTE:
return routes_receive_message_newroute (msg, arg);
break;
case RTM_DELROUTE:
return routes_receive_message_delroute (msg, arg);
break;
}
return NL_SKIP;
}
static gboolean _netlink_events_handle_read (GIOChannel *source, GIOCondition condition, gpointer data) {
struct nl_sock *socket = (struct nl_sock *) data;
nl_recvmsgs_default (socket);
return TRUE;
}
static gboolean _netlink_events_handle_route_ask (GIOChannel *source, GIOCondition condition, gpointer data) {
NetworkInadorHandle *handle = (NetworkInadorHandle *) data;
char buffer[8192];
int ret;
ret = read (handle->pipe_routes[0], buffer, sizeof (buffer));
if (ret > 0) {
/* Leimos algo en el aviso de re-procesar rutas */
routes_ask (handle);
} else if (ret == 0) {
/* Cerrar el pipe */
close (handle->pipe_routes[0]);
handle->pipe_routes[0] = -1;
return FALSE;
}
return TRUE;
}
void netlink_events_create_pair (NetlinkEventPair *pair, int family) {
struct nl_sock * sock_req;
int fd;
GIOChannel *channel;
if (pair == NULL) return;
sock_req = nl_socket_alloc ();
if (nl_connect (sock_req, family) != 0) {
perror ("Falló conectar netlink socket para eventos\n");
return;
}
nl_socket_set_nonblocking (sock_req);
nl_socket_disable_seq_check (sock_req);
fd = nl_socket_get_fd (sock_req);
fcntl (fd, F_SETFD, 1);
channel = g_io_channel_unix_new (fd);
pair->source = g_io_add_watch (channel, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP, _netlink_events_handle_read, sock_req);
pair->nl_sock = sock_req;
g_io_channel_unref (channel);
}
void netlink_events_clear_pair (NetlinkEventPair *pair) {
g_source_remove (pair->source);
pair->source = 0;
/* Cerrar el socket */
nl_close (pair->nl_sock);
pair->nl_sock = NULL;
}
void netlink_events_setup (NetworkInadorHandle *handle) {
int ret;
GIOChannel *channel;
netlink_events_create_pair (&handle->route_events, NETLINK_ROUTE);
int flags;
nl_socket_add_memberships (handle->route_events.nl_sock, RTNLGRP_LINK, RTNLGRP_IPV4_IFADDR, RTNLGRP_IPV6_IFADDR, RTNLGRP_IPV6_IFINFO, RTNLGRP_IPV4_ROUTE, RTNLGRP_IPV6_ROUTE, 0);
nl_socket_modify_cb (handle->route_events.nl_sock, NL_CB_VALID, NL_CB_CUSTOM, _netlink_events_route_dispatcher, handle);
/* Crear un pipe para vigilar y procesar los cambios de rutas */
ret = pipe (handle->pipe_routes);
if (ret < 0) {
handle->pipe_routes[0] = handle->pipe_routes[1] = -1;
} else {
flags = fcntl (handle->pipe_routes[0], F_GETFL);
fcntl (handle->pipe_routes[0], F_SETFL, flags | O_NONBLOCK);
channel = g_io_channel_unix_new (handle->pipe_routes[0]);
handle->source_pipe_routes = g_io_add_watch (channel, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP, _netlink_events_handle_route_ask, handle);
g_io_channel_unref (channel);
}
}
void netlink_events_clear (NetworkInadorHandle *handle) {
/* Primero, detener los eventos del source watch */
netlink_events_clear_pair (&handle->route_events);
}

12
lib/netlink-events.h → src/netlink-events.h
View File

@ -23,13 +23,11 @@
#ifndef __NETLINK_EVENTS_H__
#define __NETLINK_EVENTS_H__
#include <netlink/socket.h>
#include <netlink/msg.h>
#include "common.h"
#include "network-inador-private.h"
int netlink_events_route_dispatcher (struct nl_msg *msg, void *arg);
void netlink_events_route_events_handle_read (void *data, int fd, int condition);
void netlink_events_pipe_route_handle_read (void *data, int fd, int condition);
void netlink_events_create_pair (NetlinkEventPair *pair, int family);
void netlink_events_clear_pair (NetlinkEventPair *pair);
void netlink_events_setup (NetworkInadorHandle *handle);
void netlink_events_clear (NetworkInadorHandle *handle);
#endif

0
lib/resolv_conf_defs.h → src/resolv_conf_defs.h
View File

14
src/resolv_conf_helper.c
View File

@ -34,7 +34,7 @@
#include <sys/un.h>
#include <arpa/inet.h>
#include "flist.h"
#include "glist.h"
#include "network-inador-manager.h"
#include "resolv_conf_defs.h"
@ -76,10 +76,10 @@ int wait_for_ack_or_error (int s) {
return -1;
}
FList * helper_parser_parse_input (FList *all_entries, FILE *fd, int origin) {
GList * helper_parser_parse_input (GList *all_entries, FILE *fd, int origin) {
char buffer[8192], value[2048];
ResolvConfEntry *entry = NULL;
FList *pos, *next;
GList *pos, *next;
int g, len;
struct_addr direccion;
int type;
@ -112,7 +112,7 @@ FList * helper_parser_parse_input (FList *all_entries, FILE *fd, int origin) {
entry->owner_interface_index = 0;
entry->owner_prog[0] = 0;
all_entries = f_list_append (all_entries, entry);
all_entries = g_list_append (all_entries, entry);
entry->tagged = 1;
entry->file_order = order++;
}
@ -120,10 +120,10 @@ FList * helper_parser_parse_input (FList *all_entries, FILE *fd, int origin) {
return all_entries;
}
void send_entries (int s, FList *entries, const char *iface_prog) {
void send_entries (int s, GList *entries, const char *iface_prog) {
char buffer[2048];
int pos, len, pos_name_count;
FList *g;
GList *g;
int n;
ResolvConfEntry *entry;
@ -194,7 +194,7 @@ int main (int argc, char *argv[]) {
int next_option;
const char *iface_prog = NULL;
int action = 0;
FList *entries;
GList *entries;
int s, ret;
struct sockaddr_un path_dest;

16
common/resolv_conf_parser.c → src/resolv_conf_parser.c
View File

@ -28,7 +28,11 @@
#include "resolv_conf_defs.h"
#include "resolv_conf_parser.h"
#include "utils.h"
#include "flist.h"
#ifdef STAND_ALONE_RESOLV_CONF_HELPER_BUILD
#include "glist.h"
#else
#include "common.h"
#endif
static const char *resolv_conf_keywords[NUM_RESOLV_TYPES] = {
"nameserver",
@ -84,8 +88,8 @@ int resolv_conf_parse_line (const char *line, int *ns_family, struct_addr *names
return -1;
}
FList * resolv_parser_search_entry (FList *all_entries, const int resolv_type, const int ns_family, const struct_addr *nameserver, const char *value, int skip_tagged) {
FList *g;
GList * resolv_parser_search_entry (GList *all_entries, const int resolv_type, const int ns_family, const struct_addr *nameserver, const char *value, int skip_tagged) {
GList *g;
ResolvConfEntry *entry;
g = all_entries;
@ -129,10 +133,10 @@ FList * resolv_parser_search_entry (FList *all_entries, const int resolv_type, c
return NULL;
}
FList * resolv_parser_parse_local_file (FList *all_entries, FILE *fd, int origin) {
GList * resolv_parser_parse_local_file (GList *all_entries, FILE *fd, int origin) {
char buffer[8192], value[2048];
ResolvConfEntry *entry = NULL;
FList *pos, *next;
GList *pos, *next;
int g, len;
struct_addr direccion;
int type;
@ -172,7 +176,7 @@ FList * resolv_parser_parse_local_file (FList *all_entries, FILE *fd, int origin
entry->owner_interface_index = 0;
entry->owner_prog[0] = 0;
all_entries = f_list_append (all_entries, entry);
all_entries = g_list_append (all_entries, entry);
}
entry->tagged = 1;
entry->file_order = order++;

10
common/resolv_conf_parser.h → src/resolv_conf_parser.h
View File

@ -26,11 +26,15 @@
#include <stdio.h>
#include <stdlib.h>
#include "flist.h"
#ifdef STAND_ALONE_RESOLV_CONF_HELPER_BUILD
#include "glist.h"
#else
#include "common.h"
#endif
int resolv_conf_parse_line (const char *line, int *ns_family, struct_addr *nameserver, char *value, const size_t value_size);
FList * resolv_parser_search_entry (FList *all_entries, const int resolv_type, const int ns_family, const struct_addr *nameserver, const char *value, int skip_on_file);
FList * resolv_parser_parse_local_file (FList *all_entries, FILE *fd, int origin);
GList * resolv_parser_search_entry (GList *all_entries, const int resolv_type, const int ns_family, const struct_addr *nameserver, const char *value, int skip_on_file);
GList * resolv_parser_parse_local_file (GList *all_entries, FILE *fd, int origin);
#endif /* __RESOLV_CONF_PARSER_H__ */

32
lib/resolv_manager.c → src/resolv_manager.c
View File

@ -30,14 +30,14 @@
#include <arpa/inet.h>
#include "resolv_manager.h"
#include "network-inador-private.h"
#include "common.h"
#include "utils.h"
#include "resolv_conf_parser.h"
#include "interfaces.h"
void resolv_manager_write (NetworkInadorHandle *handle);
int resolv_manager_sort_entries (const void *a, const void *b, void * data) {
gint resolv_manager_sort_entries (const void *a, const void *b, gpointer data) {
const ResolvConfEntry *aa = (ResolvConfEntry *) a;
const ResolvConfEntry *bb = (ResolvConfEntry *) b;
@ -64,7 +64,7 @@ int resolv_manager_sort_entries (const void *a, const void *b, void * data) {
}
void resolv_manager_clear_entries_by_prog (NetworkInadorHandle *handle, const int iface_index, const char *prog) {
FList *g;
GList *g;
ResolvConfEntry *entry;
int do_write = 0;
@ -83,7 +83,7 @@ void resolv_manager_clear_entries_by_prog (NetworkInadorHandle *handle, const in
printf ("/// Eliminando entrada %s por via resolvconf. Prog = «%s»\n", entry->value, prog);
/*free (entry);
handle->resolver_entries = f_list_delete_link (handle->resolver_entries, g);*/
handle->resolver_entries = g_list_delete_link (handle->resolver_entries, g);*/
entry->for_purge = 1;
do_write = 1;
}
@ -98,7 +98,7 @@ void resolv_manager_clear_entries_by_prog (NetworkInadorHandle *handle, const in
}
void resolv_manager_clear_tag_on_all (NetworkInadorHandle *handle) {
FList *pos;
GList *pos;
ResolvConfEntry *entry;
/* Borrar el atributo "tagged" */
@ -114,7 +114,7 @@ void resolv_manager_clear_tag_on_all (NetworkInadorHandle *handle) {
void resolv_manager_process_resolvconf_entries (NetworkInadorHandle *handle, ResolvConfEntry *entries, int num_entries) {
int g;
ResolvConfEntry *entry;
FList *pos_entry;
GList *pos_entry;
int do_write = 0;
resolv_manager_clear_tag_on_all (handle);
@ -163,7 +163,7 @@ void resolv_manager_process_resolvconf_entries (NetworkInadorHandle *handle, Res
entry->for_purge = 0;
/* Anexar al final de la lista */
handle->resolver_entries = f_list_append (handle->resolver_entries, entry);
handle->resolver_entries = g_list_append (handle->resolver_entries, entry);
/* TODO: Como creamos una entrada via el resolvconf, regenerar el archivo */
printf ("/// Nueva entrada %s via resolvconf, programando regeneración.\n", entry->value);
@ -178,7 +178,7 @@ void resolv_manager_process_resolvconf_entries (NetworkInadorHandle *handle, Res
}
void resolv_manager_process_dhcp_nameservers (NetworkInadorHandle *handle, Interface *iface) {
FList *pos_entry;
GList *pos_entry;
int h;
ResolvConfEntry *entry;
int do_write = 0;
@ -245,7 +245,7 @@ void resolv_manager_process_dhcp_nameservers (NetworkInadorHandle *handle, Inter
inet_ntop (AF_INET, &entry->nameserver, entry->value, sizeof (entry->value));
/* Anexar al final de la lista */
handle->resolver_entries = f_list_append (handle->resolver_entries, entry);
handle->resolver_entries = g_list_append (handle->resolver_entries, entry);
/* Como creamos una entrada via el dhcp, regenerar el archivo */
printf ("/// Nueva entrada %s via DHCP (%s), programando regeneración.\n", entry->value, iface->name);
@ -299,7 +299,7 @@ void resolv_manager_process_dhcp_nameservers (NetworkInadorHandle *handle, Inter
strncpy (entry->value, iface->dhcpc.domain_name, sizeof (entry->value));
/* Anexar al final de la lista */
handle->resolver_entries = f_list_append (handle->resolver_entries, entry);
handle->resolver_entries = g_list_append (handle->resolver_entries, entry);
/* Como creamos una entrada via el dhcp, regenerar el archivo */
printf ("/// Nueva entrada search %s via DHCP (%s), programando regeneración.\n", entry->value, iface->name);
@ -327,7 +327,7 @@ void resolv_manager_process_dhcp_nameservers (NetworkInadorHandle *handle, Inter
}
void resolv_manager_clear_dhcp_nameservers (NetworkInadorHandle *handle, Interface *iface) {
FList *pos_entry;
GList *pos_entry;
int h;
ResolvConfEntry *entry;
int do_write = 0;
@ -356,7 +356,7 @@ void resolv_manager_clear_dhcp_nameservers (NetworkInadorHandle *handle, Interfa
void resolv_manager_read_local_etc_resolv (NetworkInadorHandle *handle) {
FILE *fd;
FList *pos, *next;
GList *pos, *next;
ResolvConfEntry *entry;
fd = fopen ("/etc/resolv.conf", "r");
@ -381,7 +381,7 @@ void resolv_manager_read_local_etc_resolv (NetworkInadorHandle *handle) {
printf ("/// La entrada %s del resolv.conf fué eliminada del archivo. Purgando nosotros.\n", entry->value);
entry->for_purge = 1;
/*handle->resolver_entries = f_list_delete_link (handle->resolver_entries, pos);
/*handle->resolver_entries = g_list_delete_link (handle->resolver_entries, pos);
free (entry);
entry = NULL;*/
} else {
@ -391,12 +391,12 @@ void resolv_manager_read_local_etc_resolv (NetworkInadorHandle *handle) {
}
/* Reordenar las entradas. TODO: Falta leer los ficheros de configuración del resolv.conf */
handle->resolver_entries = f_list_sort_with_data (handle->resolver_entries, resolv_manager_sort_entries, NULL);
handle->resolver_entries = g_list_sort_with_data (handle->resolver_entries, resolv_manager_sort_entries, NULL);
}
void resolv_manager_write (NetworkInadorHandle *handle) {
FILE *fd;
FList *pos, *next;
GList *pos, *next;
ResolvConfEntry *entry;
Interface *iface;
@ -456,7 +456,7 @@ void resolv_manager_write (NetworkInadorHandle *handle) {
entry = (ResolvConfEntry *) pos->data;
if (entry->for_purge == 1) {
handle->resolver_entries = f_list_delete_link (handle->resolver_entries, pos);
handle->resolver_entries = g_list_delete_link (handle->resolver_entries, pos);
free (entry);
entry = NULL;
}

3
lib/resolv_manager.h → src/resolv_manager.h
View File

@ -23,10 +23,9 @@
#ifndef __RESOLV_MANAGER_H__
#define __RESOLV_MANAGER_H__
#include "network-inador-private.h"
#include "common.h"
#include "struct_addr_union.h"
#include "resolv_conf_defs.h"
#include "interfaces.h"
void resolv_manager_init (NetworkInadorHandle *handle);
void resolv_manager_clear_entries_by_prog (NetworkInadorHandle *handle, const int iface_index, const char *prog);

115
lib/routes.c → src/routes.c
View File

@ -34,13 +34,12 @@
#include <netlink/socket.h>
#include <netlink/msg.h>
#include "flist.h"
#include "network-inador-private.h"
#include "common.h"
#include "routes.h"
//#include "manager.h"
#include "manager.h"
int _route_compare_nexthop_v4 (const void * a, const void * b);
int _route_compare_nexthop_v6 (const void * a, const void * b);
gint _route_compare_nexthop_v4 (gconstpointer a, gconstpointer b);
gint _route_compare_nexthop_v6 (gconstpointer a, gconstpointer b);
void route_ask_delayed_delroute (NetworkInadorHandle *handle) {
if (handle->pipe_routes[1] > 0) {
@ -48,14 +47,14 @@ void route_ask_delayed_delroute (NetworkInadorHandle *handle) {
}
}
int _route_same_list_nexthops (int family, FList *nexthops_a, FList *nexthops_b) {
int _route_same_list_nexthops (int family, GList *nexthops_a, GList *nexthops_b) {
int count_a, count_b;
RouteNH *nha, *nhb;
FList *p_a, *p_b;
GList *p_a, *p_b;
count_a = f_list_length (nexthops_a);
count_b = f_list_length (nexthops_b);
count_a = g_list_length (nexthops_a);
count_b = g_list_length (nexthops_b);
if (count_a != count_b) return 1;
@ -78,8 +77,8 @@ int _route_same_list_nexthops (int family, FList *nexthops_a, FList *nexthops_b)
return 0;
}
Route *_route_search_route (FList *list_routes, sa_family_t family, uint8_t tos, uint32_t table, void *dest, uint32_t prefix, uint32_t priority) {
FList *g;
Route *_route_search_route (GList *list_routes, sa_family_t family, uint8_t tos, uint32_t table, void *dest, uint32_t prefix, uint32_t priority) {
GList *g;
Route *route;
int family_size = 0;
@ -108,7 +107,7 @@ Route *_route_search_route (FList *list_routes, sa_family_t family, uint8_t tos,
return NULL;
}
int _route_compare_nexthop_v4 (const void * a, const void * b) {
gint _route_compare_nexthop_v4 (gconstpointer a, gconstpointer b) {
int ret;
RouteNH *nha = (RouteNH *) a, *nhb = (RouteNH *) b;
@ -124,7 +123,7 @@ int _route_compare_nexthop_v4 (const void * a, const void * b) {
return ret;
}
int _route_compare_nexthop_v6 (const void * a, const void * b) {
gint _route_compare_nexthop_v6 (gconstpointer a, gconstpointer b) {
int ret;
RouteNH *nha = (RouteNH *) a, *nhb = (RouteNH *) b;
@ -140,11 +139,11 @@ int _route_compare_nexthop_v6 (const void * a, const void * b) {
return ret;
}
FList * _route_sort_nexthops (int family, FList *nexthops) {
GList * _route_sort_nexthops (int family, GList *nexthops) {
if (family == AF_INET) {
return f_list_sort (nexthops, _route_compare_nexthop_v4);
return g_list_sort (nexthops, _route_compare_nexthop_v4);
} else if (family == AF_INET6) {
return f_list_sort (nexthops, _route_compare_nexthop_v6);
return g_list_sort (nexthops, _route_compare_nexthop_v6);
}
return nexthops;
@ -168,8 +167,8 @@ int routes_receive_message_newroute (struct nl_msg *msg, void *arg) {
struct_addr dest;
uint32_t priority = 0;
int was_new = 0, was_update = 0;
FList *route_list = NULL;
FList *old_next_hops = NULL;
GList *route_list = NULL;
GList *old_next_hops = NULL;
reply = nlmsg_hdr (msg);
@ -243,14 +242,14 @@ int routes_receive_message_newroute (struct nl_msg *msg, void *arg) {
memcpy (&route->dest, &dest, family_size);
if (family == AF_INET) {
handle->route_v4_tables = f_list_append (handle->route_v4_tables, route);
handle->route_v4_tables = g_list_append (handle->route_v4_tables, route);
} else if (family == AF_INET6) {
handle->route_v6_tables = f_list_append (handle->route_v6_tables, route);
handle->route_v6_tables = g_list_append (handle->route_v6_tables, route);
}
was_new = 1;
} else {
/* Liberar los next-hops, puesto que volverán a ser creados */
//f_list_free_full (route->nexthops, free);
//g_list_free_full (route->nexthops, free);
old_next_hops = route->nexthops;
route->nexthops = NULL;
route->for_delete = 0;
@ -314,7 +313,7 @@ int routes_receive_message_newroute (struct nl_msg *msg, void *arg) {
/* Reservar el siguiente next-hop */
if (multipath_len > 0) {
route->nexthops = f_list_append (route->nexthops, next_hop);
route->nexthops = g_list_append (route->nexthops, next_hop);
next_hop = (RouteNH *) malloc (sizeof (RouteNH));
memset (next_hop, 0, sizeof (RouteNH));
@ -324,7 +323,7 @@ int routes_receive_message_newroute (struct nl_msg *msg, void *arg) {
}
}
route->nexthops = f_list_append (route->nexthops, next_hop);
route->nexthops = g_list_append (route->nexthops, next_hop);
route->nexthops = _route_sort_nexthops (family, route->nexthops);
if (_route_same_list_nexthops (family, route->nexthops, old_next_hops) == 1) {
@ -333,14 +332,14 @@ int routes_receive_message_newroute (struct nl_msg *msg, void *arg) {
}
/* Liberar la lista vieja de next_hops */
f_list_free_full (old_next_hops, free);
g_list_free_full (old_next_hops, free);
if (was_new) {
/* Enviar aquí evento de ruta agregada */
//manager_send_event_route_add (handle, route);
manager_send_event_route_add (handle, route);
} else if (was_update) {
/* Enviar actualización */
//manager_send_event_route_update (handle, route);
manager_send_event_route_update (handle, route);
}
return NL_SKIP;
}
@ -357,7 +356,7 @@ int routes_receive_message_delroute (struct nl_msg *msg, void *arg) {
uint8_t route_tos;
struct_addr dest;
uint32_t priority = 0;
FList *route_list = NULL;
GList *route_list = NULL;
reply = nlmsg_hdr (msg);
if (reply->nlmsg_type != RTM_DELROUTE) return NL_SKIP;
@ -419,16 +418,16 @@ int routes_receive_message_delroute (struct nl_msg *msg, void *arg) {
if (family == AF_INET) {
/* Eliminar de la lista ligada */
handle->route_v4_tables = f_list_remove (handle->route_v4_tables, route);
handle->route_v4_tables = g_list_remove (handle->route_v4_tables, route);
} else if (family == AF_INET6) {
handle->route_v6_tables = f_list_remove (handle->route_v6_tables, route);
handle->route_v6_tables = g_list_remove (handle->route_v6_tables, route);
}
/* Notificar del evento */
//manager_send_event_route_del (handle, route);
manager_send_event_route_del (handle, route);
/* Eliminar todos los next-hops primero */
f_list_free_full (route->nexthops, free);
g_list_free_full (route->nexthops, free);
free (route);
@ -467,7 +466,7 @@ int routes_add (NetworkInadorHandle *handle, Route *route) {
struct_addr empty;
int hop_count;
RouteNH *nh;
FList *g;
GList *g;
struct rtnexthop nexthop_hdr, *nhptr;
char buffer_nexthops[8192];
int size_nexthops;
@ -507,7 +506,7 @@ int routes_add (NetworkInadorHandle *handle, Route *route) {
ret |= nla_put (msg, RTA_PREFSRC, family_size, &route->prefsrc);
}
hop_count = f_list_length (route->nexthops);
hop_count = g_list_length (route->nexthops);
if (hop_count <= 1) {
/* Agregar por el método 1 */
nh = (RouteNH *) route->nexthops->data;
@ -593,7 +592,7 @@ int routes_del (NetworkInadorHandle *handle, Route *route) {
struct_addr empty;
int hop_count;
RouteNH *nh;
FList *g;
GList *g;
memset (&route_hdr, 0, sizeof (route_hdr));
@ -658,7 +657,7 @@ void routes_ask (NetworkInadorHandle *handle) {
.rtm_family = AF_UNSPEC,
};
int ret;
FList *g, *n;
GList *g, *n;
Route *r;
/* Recorrer todas las rutas en la tabla de ruteo y marcarlas para eliminación */
@ -703,13 +702,13 @@ void routes_ask (NetworkInadorHandle *handle) {
r = (Route *) g->data;
if (r->for_delete == 0) continue;
handle->route_v4_tables = f_list_remove (handle->route_v4_tables, r);
handle->route_v4_tables = g_list_remove (handle->route_v4_tables, r);
/* Notificar del evento */
//manager_send_event_route_del (handle, r);
manager_send_event_route_del (handle, r);
/* Eliminar todos los next-hops primero */
f_list_free_full (r->nexthops, free);
g_list_free_full (r->nexthops, free);
free (r);
}
@ -720,19 +719,19 @@ void routes_ask (NetworkInadorHandle *handle) {
r = (Route *) g->data;
if (r->for_delete == 0) continue;
handle->route_v6_tables = f_list_remove (handle->route_v6_tables, r);
handle->route_v6_tables = g_list_remove (handle->route_v6_tables, r);
/* Notificar del evento */
//manager_send_event_route_del (handle, r);
manager_send_event_route_del (handle, r);
/* Eliminar todos los next-hops primero */
f_list_free_full (r->nexthops, free);
g_list_free_full (r->nexthops, free);
free (r);
}
}
int _routes_table_find_by_number (const void * left, const void * right) {
gint _routes_table_find_by_number (gconstpointer left, gconstpointer right) {
RouteTable *a, *b;
a = (RouteTable *) left;
@ -742,7 +741,7 @@ int _routes_table_find_by_number (const void * left, const void * right) {
}
void _routes_table_parse_file (NetworkInadorHandle *handle, FILE *fd) {
FList *g;
GList *g;
int ret;
RouteTable *rtable, temp_table;
char buffer[2048];
@ -756,7 +755,7 @@ void _routes_table_parse_file (NetworkInadorHandle *handle, FILE *fd) {
continue;
}
g = f_list_find_custom (handle->route_tables_names, &temp_table, _routes_table_find_by_number);
g = g_list_find_custom (handle->route_tables_names, &temp_table, _routes_table_find_by_number);
if (g != NULL) {
/* El número de tabla ya existe, marcar y actualizar el nombre */
@ -766,7 +765,7 @@ void _routes_table_parse_file (NetworkInadorHandle *handle, FILE *fd) {
rtable->was_new = 0;
} else {
/* No existe, crear nueva */
rtable = (RouteTable *) malloc (sizeof (RouteTable));
rtable = (RouteTable *) g_malloc (sizeof (RouteTable));
rtable->table = temp_table.table;
rtable->for_delete = 0;
rtable->was_new = 1;
@ -774,13 +773,13 @@ void _routes_table_parse_file (NetworkInadorHandle *handle, FILE *fd) {
/* En cualquier caso actualizar el nombre */
strncpy (rtable->name, temp_table.name, sizeof (rtable->name));
handle->route_tables_names = f_list_append (handle->route_tables_names, rtable);
handle->route_tables_names = g_list_append (handle->route_tables_names, rtable);
}
}
void routes_tables_read (NetworkInadorHandle *handle, int do_notify) {
FILE *fd;
FList *g, *h;
GList *g, *h;
RouteTable *rtable;
DIR *dir;
struct dirent *direntry;
@ -796,7 +795,7 @@ void routes_tables_read (NetworkInadorHandle *handle, int do_notify) {
g = g->next;
}
//f_list_free_full (handle->route_tables_names, g_free);
//g_list_free_full (handle->route_tables_names, g_free);
//handle->route_tables_names = NULL;
/* Intentar abrir /etc/iproute2/rt_tables */
@ -840,13 +839,13 @@ void routes_tables_read (NetworkInadorHandle *handle, int do_notify) {
rtable = (RouteTable *) g->data;
if (rtable->for_delete) {
handle->route_tables_names = f_list_delete_link (handle->route_tables_names, g);
handle->route_tables_names = g_list_delete_link (handle->route_tables_names, g);
if (do_notify) {
//manager_send_event_route_table_del (handle, rtable);
manager_send_event_route_table_del (handle, rtable);
}
free (rtable);
g_free (rtable);
}
g = h;
@ -858,7 +857,7 @@ void routes_tables_read (NetworkInadorHandle *handle, int do_notify) {
if (rtable->was_new) {
if (do_notify) {
//manager_send_event_route_table_add (handle, rtable);
manager_send_event_route_table_add (handle, rtable);
}
rtable->was_new = 0;
}
@ -876,29 +875,27 @@ void routes_init (NetworkInadorHandle *handle) {
}
void routes_clean_up (NetworkInadorHandle *handle) {
FList *g;
GList *g;
Route *route;
for (g = handle->route_v4_tables; g != NULL; g = g->next) {
route = (Route *) g->data;
f_list_free_full (route->nexthops, free);
g_list_free_full (route->nexthops, free);
route->nexthops = NULL;
}
f_list_free_full (handle->route_v4_tables, free);
g_list_free_full (handle->route_v4_tables, free);
handle->route_v4_tables = NULL;
for (g = handle->route_v6_tables; g != NULL; g = g->next) {
route = (Route *) g->data;
f_list_free_full (route->nexthops, free);
g_list_free_full (route->nexthops, free);
route->nexthops = NULL;
}
f_list_free_full (handle->route_v6_tables, free);
g_list_free_full (handle->route_v6_tables, free);
handle->route_v6_tables = NULL;
/* FIXME: Falta liberar el nombre de las tablas */
}

44
lib/routes.h → src/routes.h
View File

@ -23,52 +23,10 @@
#ifndef __ROUTES_H__
#define __ROUTES_H__
#include <stdint.h>
#include <netlink/socket.h>
#include <netlink/msg.h>
#include "network-inador-private.h"
#include "struct_addr_union.h"
#include "flist.h"
/* Un Next-hop */
typedef struct {
struct_addr gw;
uint32_t out_index;
uint8_t nh_weight;
uint8_t nh_flags;
} RouteNH;
/* La tabla de ruteo */
typedef struct {
sa_family_t family; /* AF_INET, AF_INET6 */
uint8_t type; /* Unicast, local, broadcast, etc... */
uint32_t table;
struct_addr dest;
uint8_t prefix;
uint8_t tos;
uint8_t protocol;
uint8_t scope;
struct_addr prefsrc;
uint32_t priority;
/* Los brincos */
FList *nexthops;
/* Variable usada para determinar si debemos eliminar la ruta */
int for_delete;
} Route;
typedef struct {
uint32_t table;
char name[256];
int for_delete, was_new;
} RouteTable;
#include "common.h"
void routes_init (NetworkInadorHandle *handle);
void routes_ask (NetworkInadorHandle *handle);

0
lib/struct_addr_union.h → src/struct_addr_union.h
View File

2
common/utils.c → src/utils.c
View File

@ -32,7 +32,7 @@ void utils_trim (char * s) {
char * p = s;
int l = strlen(p);
while(l > 0 && isspace(p[l - 1])) p[--l] = 0;
while(isspace(p[l - 1])) p[--l] = 0;
while(* p && isspace(* p)) ++p, --l;
memmove(s, p, l + 1);

0
common/utils.h → src/utils.h
View File

8
lib/wireless_bss.c → src/wireless_bss.c
View File

@ -33,7 +33,7 @@
#include <linux/nl80211.h>
#include "network-inador-private.h"
#include "common.h"
#include "interfaces.h"
#include "netlink-events.h"
#include "wireless_if.h"
@ -43,7 +43,7 @@
int wireless_bss_finish_scan (struct nl_msg *msg, void *arg) {
#if 0
FList *g;
GList *g;
WirelessBSS *bss;
printf ("Scan finish handler\n");
@ -71,7 +71,7 @@ static void _wireless_bss_find_ssid (uint8_t *ies, uint32_t ies_len, uint8_t **s
}
static WirelessBSS * _wireless_bss_get (Interface *iface, const uint8_t *bssid, const uint8_t *ssid, int ssid_len) {
FList *g;
GList *g;
WirelessBSS *bss;
if (iface->is_wireless == 0) return NULL;
@ -100,7 +100,7 @@ static WirelessBSS * _wireless_bss_add_bss (Interface *iface, WirelessBSS *bss)
new->last_update_idx = iface->wireless->bss_update_idx;
new->scan_miss_count = 0;
iface->wireless->aps = f_list_append (iface->wireless->aps, new);
iface->wireless->aps = g_list_append (iface->wireless->aps, new);
}
static void _wireless_bss_update_bss (Interface *iface, WirelessBSS *bss, WirelessBSS *updated) {

2
lib/wireless_bss.h → src/wireless_bss.h
View File

@ -36,6 +36,8 @@
#include <linux/nl80211.h>
#include "common.h"
int wireless_bss_parse_station_scan (struct nl_msg *msg, void *arg);
int wireless_bss_finish_scan (struct nl_msg *msg, void *arg);

14
lib/wireless_if.c → src/wireless_if.c
View File

@ -33,7 +33,7 @@
#include <linux/nl80211.h>
#include "network-inador-private.h"
#include "common.h"
#include "interfaces.h"
#include "netlink-events.h"
#include "wireless_if.h"
@ -78,7 +78,7 @@ static void _wireless_if_process_bands (struct nlattr *list_bands, WirelessInfo
}
printf ("La supuesta cantidad de frecuencias es: %i\n", info->num_freqs);
info->freqs = (uint32_t *) malloc (sizeof (uint32_t) * info->num_freqs);
info->freqs = (guint32 *) malloc (sizeof (guint32) * info->num_freqs);
freq_index = 0;
nla_for_each_nested (band, list_bands, remaining) {
@ -243,7 +243,6 @@ gboolean wireless_interface_timer_trigger (gpointer data) {
#endif
static void wireless_interface_init_nl80211 (NetworkInadorHandle *handle) {
#if 0
int family_id;
int mcid;
struct nl_sock * sock_req;
@ -285,11 +284,9 @@ static void wireless_interface_init_nl80211 (NetworkInadorHandle *handle) {
/* Instalar un timer para ejecutar TRIGGER_SCAN cada minuto */
//g_timeout_add_seconds (50, wireless_interface_timer_trigger, handle);
#endif
}
int wireless_events_dispatcher (struct nl_msg *msg, void *arg) {
#if 0
NetworkInadorHandle *handle = (NetworkInadorHandle *) arg;
struct nlmsghdr *reply;
struct genlmsghdr *gnlh;
@ -346,11 +343,9 @@ int wireless_events_dispatcher (struct nl_msg *msg, void *arg) {
}
return NL_SKIP;
#endif
}
void wireless_interface_trigger_scan (NetworkInadorHandle *handle, Interface *iface) {
#if 0
struct nl_msg *msg;
int error, ret;
struct nlattr *ssid;
@ -396,11 +391,9 @@ void wireless_interface_trigger_scan (NetworkInadorHandle *handle, Interface *if
printf ("Error al hacer NL80211_CMD_TRIGGER_SCAN error = %i\n", error);
return;
}
#endif
}
void wireless_interface_get_scan (NetworkInadorHandle *handle, Interface *iface) {
#if 0
struct nl_msg *msg;
int error, ret;
struct genlmsghdr *gnlh;
@ -448,11 +441,9 @@ void wireless_interface_get_scan (NetworkInadorHandle *handle, Interface *iface)
}
//nl_recvmsgs_default (handle->nl_sock_nl80211);
#endif
}
void wireless_interface_check (NetworkInadorHandle *handle, Interface *iface) {
#if 0
struct nl_msg * msg;
int ret;
struct _wireless_iface_is_wifi is_wifi;
@ -512,5 +503,4 @@ void wireless_interface_check (NetworkInadorHandle *handle, Interface *iface) {
} else {
free (info);
}
#endif
}

7
lib/wireless_if.h → src/wireless_if.h
View File

@ -23,12 +23,7 @@
#ifndef __WIRELESS_IF_H__
#define __WIRELESS_IF_H__
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include "network-inador-private.h"
#include "interfaces.h"
#include "common.h"
typedef enum { /*< flags >*/
WIFI_DEVICE_CAP_NONE = 0x00000000,