295 lines
7.2 KiB
C
295 lines
7.2 KiB
C
/*
|
|
* manager.c
|
|
* This file is part of Network-inador
|
|
*
|
|
* Copyright (C) 2011 - 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 <glib.h>
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/un.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include "manager.h"
|
|
#include "interfaces.h"
|
|
#include "network-inador.h"
|
|
|
|
#define SOCKET_PATH "/tmp/network-inador.socket"
|
|
|
|
enum {
|
|
MANAGER_COMMAND_REQUEST = 0,
|
|
MANAGER_COMMAND_LIST_IFACES = 0,
|
|
|
|
MANAGER_COMMAND_SET_IPV4,
|
|
|
|
MANAGER_COMMAND_LIST_ROUTES,
|
|
|
|
MANAGER_RESPONSE = 128,
|
|
MANAGER_RESPONSE_REQUEST_INVALID = 128,
|
|
MANAGER_RESPONSE_PROCESING,
|
|
MANAGER_RESPONSE_LIST_IFACES,
|
|
|
|
MANAGER_RESPONSE_LIST_ROUTES,
|
|
};
|
|
|
|
#define MANAGER_IFACE_TYPE_WIRELESS 0x02
|
|
#define MANAGER_IFACE_TYPE_BRIDGE 0x04
|
|
#define MANAGER_IFACE_TYPE_LOOPBACK 0x8
|
|
#define MANAGER_IFACE_TYPE_VLAN 0x10
|
|
#define MANAGER_IFACE_TYPE_NLMON 0x20
|
|
|
|
static void _manager_send_invalid_request (int sock, struct sockaddr_un *client, socklen_t socklen, int seq) {
|
|
unsigned char buffer[128];
|
|
|
|
buffer[0] = MANAGER_RESPONSE_REQUEST_INVALID;
|
|
buffer[1] = seq;
|
|
|
|
sendto (sock, buffer, 2, 0, (struct sockaddr *) client, socklen);
|
|
}
|
|
|
|
static void _manager_send_processing (int sock, struct sockaddr_un *client, socklen_t socklen, int seq) {
|
|
unsigned char buffer[128];
|
|
|
|
buffer[0] = MANAGER_RESPONSE_PROCESING;
|
|
buffer[1] = seq;
|
|
|
|
sendto (sock, buffer, 2, 0, (struct sockaddr *) client, socklen);
|
|
}
|
|
|
|
static void _manager_send_list_interfaces (NetworkInadorHandle *handle, int sock, struct sockaddr_un *client, socklen_t socklen, int seq) {
|
|
unsigned char buffer[8192];
|
|
Interface *iface_g;
|
|
int pos;
|
|
int flags;
|
|
|
|
buffer[0] = MANAGER_RESPONSE_LIST_IFACES;
|
|
buffer[1] = seq;
|
|
|
|
iface_g = handle->interfaces;
|
|
|
|
pos = 2;
|
|
while (iface_g != NULL) {
|
|
buffer[pos] = iface_g->index;
|
|
flags = 0;
|
|
|
|
if (iface_g->is_loopback) {
|
|
flags |= MANAGER_IFACE_TYPE_LOOPBACK;
|
|
}
|
|
|
|
if (iface_g->is_wireless) {
|
|
flags |= MANAGER_IFACE_TYPE_WIRELESS;
|
|
}
|
|
|
|
if (iface_g->is_bridge) {
|
|
flags |= MANAGER_IFACE_TYPE_BRIDGE;
|
|
}
|
|
|
|
if (iface_g->is_vlan) {
|
|
flags |= MANAGER_IFACE_TYPE_VLAN;
|
|
}
|
|
|
|
if (iface_g->is_nlmon) {
|
|
flags |= MANAGER_IFACE_TYPE_NLMON;
|
|
}
|
|
|
|
buffer[pos + 1] = flags;
|
|
|
|
/* Copiar la mac address */
|
|
memcpy (&buffer[pos + 2], iface_g->real_hw, ETHER_ADDR_LEN);
|
|
|
|
/* Copiar el nombre y el terminador de cadena */
|
|
memcpy (&buffer[pos + 2 + ETHER_ADDR_LEN], iface_g->name, strlen (iface_g->name) + 1);
|
|
|
|
pos += 2 + ETHER_ADDR_LEN + strlen (iface_g->name) + 1;
|
|
iface_g = iface_g->next;
|
|
}
|
|
|
|
buffer[pos] = 0;
|
|
pos++;
|
|
|
|
sendto (sock, buffer, pos, 0, (struct sockaddr *) client, socklen);
|
|
}
|
|
|
|
static void _manager_handle_interface_set_ipv4 (NetworkInadorHandle *handle, char *buffer_read, int len, int sock, struct sockaddr_un *client, socklen_t socklen, int seq) {
|
|
/* Primero, validar que haya suficientes bytes:
|
|
* 1 byte de la interfaz
|
|
* 4 bytes de la dirección
|
|
* 1 byte del prefix
|
|
*/
|
|
uint32_t prefix;
|
|
struct in_addr sin_addr;
|
|
int index;
|
|
Interface *iface;
|
|
IPv4 address;
|
|
|
|
if (len < 6) {
|
|
/* Bytes unsuficientes */
|
|
_manager_send_invalid_request (sock, client, socklen, seq);
|
|
|
|
return;
|
|
}
|
|
|
|
prefix = buffer_read[5];
|
|
|
|
if (prefix < 0 || prefix > 32) {
|
|
_manager_send_invalid_request (sock, client, socklen, seq);
|
|
return;
|
|
}
|
|
|
|
index = buffer_read[0];
|
|
|
|
iface = interfaces_locate_by_index (handle->interfaces, index);
|
|
|
|
if (iface == NULL) {
|
|
_manager_send_invalid_request (sock, client, socklen, seq);
|
|
return;
|
|
}
|
|
|
|
memcpy (&address.sin_addr, &buffer_read[1], sizeof (struct in_addr));
|
|
address.prefix = prefix;
|
|
address.next = NULL;
|
|
|
|
interfaces_clear_all_ipv4_address (handle, iface);
|
|
interfaces_manual_add_ipv4 (handle->netlink_sock_request, iface, &address);
|
|
|
|
_manager_send_processing (sock, client, socklen, seq);
|
|
}
|
|
|
|
static void _manager_send_list_routes (NetworkInadorHandle *handle, int sock, struct sockaddr_un *client, socklen_t socklen, int seq) {
|
|
unsigned char buffer[8192];
|
|
Routev4 *route_g;
|
|
int pos;
|
|
int flags;
|
|
unsigned int count;
|
|
|
|
buffer[0] = MANAGER_RESPONSE_LIST_ROUTES;
|
|
buffer[1] = seq;
|
|
|
|
route_g = handle->rtable_v4;
|
|
|
|
count = 0;
|
|
pos = 6;
|
|
while (route_g != NULL) {
|
|
memcpy (&buffer[pos], &route_g->dest, sizeof (route_g->dest));
|
|
pos = pos + sizeof (route_g->dest);
|
|
|
|
buffer[pos] = route_g->prefix;
|
|
buffer[pos + 1] = route_g->index;
|
|
buffer[pos + 2] = route_g->table;
|
|
buffer[pos + 3] = route_g->type;
|
|
pos = pos + 4;
|
|
|
|
memcpy (&buffer[pos], &route_g->gateway, sizeof (route_g->gateway));
|
|
|
|
pos = pos + 4;
|
|
|
|
route_g = route_g->next;
|
|
count++;
|
|
}
|
|
|
|
memcpy (&buffer[2], &count, sizeof (int));
|
|
|
|
sendto (sock, buffer, pos, 0, (struct sockaddr *) client, socklen);
|
|
}
|
|
|
|
static gboolean _manager_client_data (GIOChannel *source, GIOCondition condition, gpointer data) {
|
|
NetworkInadorHandle *handle = (NetworkInadorHandle *) data;
|
|
int sock;
|
|
unsigned char buffer[4096];
|
|
struct sockaddr_un client_name;
|
|
socklen_t socklen;
|
|
int len;
|
|
int seq;
|
|
|
|
sock = g_io_channel_unix_get_fd (source);
|
|
|
|
socklen = sizeof (client_name);
|
|
len = recvfrom (sock, buffer, sizeof (buffer), 0, (struct sockaddr *) &client_name, &socklen);
|
|
|
|
/* Procesar aquí la petición */
|
|
if (len < 2) {
|
|
_manager_send_invalid_request (sock, &client_name, socklen, 0);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
seq = buffer[1];
|
|
|
|
switch (buffer[0]) {
|
|
case MANAGER_COMMAND_LIST_IFACES:
|
|
_manager_send_list_interfaces (handle, sock, &client_name, socklen, seq);
|
|
break;
|
|
case MANAGER_COMMAND_SET_IPV4:
|
|
_manager_handle_interface_set_ipv4 (handle, &buffer[2], len - 2, sock, &client_name, socklen, seq);
|
|
break;
|
|
case MANAGER_COMMAND_LIST_ROUTES:
|
|
_manager_send_list_routes (handle, sock, &client_name, socklen, seq);
|
|
break;
|
|
default:
|
|
_manager_send_invalid_request (sock, &client_name, socklen, seq);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
int manager_setup_socket (NetworkInadorHandle *handle) {
|
|
int sock;
|
|
struct sockaddr_un socket_name;
|
|
GIOChannel *channel;
|
|
|
|
sock = socket (AF_UNIX, SOCK_DGRAM, 0);
|
|
|
|
if (sock < 0) {
|
|
perror ("Failed to create AF_UNIX socket");
|
|
|
|
return -1;
|
|
}
|
|
|
|
memset (&socket_name, 0, sizeof (struct sockaddr_un));
|
|
|
|
socket_name.sun_family = AF_UNIX;
|
|
strncpy (socket_name.sun_path, SOCKET_PATH, sizeof (socket_name.sun_path) - 1);
|
|
|
|
unlink (SOCKET_PATH);
|
|
|
|
if (bind (sock, (struct sockaddr *) &socket_name, sizeof (struct sockaddr_un)) < 0) {
|
|
perror ("Bind");
|
|
|
|
return -1;
|
|
}
|
|
|
|
/* TODO: Aplicar permisos aquí */
|
|
chmod (SOCKET_PATH, 0666);
|
|
|
|
channel = g_io_channel_unix_new (sock);
|
|
|
|
g_io_add_watch (channel, G_IO_IN | G_IO_PRI, _manager_client_data, handle);
|
|
|
|
return 0;
|
|
}
|