Ignore:
Timestamp:
2010-04-17T15:16:17+02:00 (7 years ago)
Author:
acinonyx
Message:

[packages] mini_snmpd: Merge mini_snmpd_ipv6 with mini_snmpd

  • add ipv6 module dependency if IPV6 support is selected
  • update ipv6 patch to compile IPv6 support conditionally
  • cleanup Makefile
  • refresh patches
File:
1 copied

Legend:

Unmodified
Added
Removed
  • packages/net/mini_snmpd/patches/104-ipv6-support.patch

    r20954 r20955  
     1--- a/globals.c 
     2+++ b/globals.c 
     3@@ -27,6 +27,9 @@ 
     4  * Global variables 
     5  */ 
     6  
     7+#ifndef IPV6 
     8+const struct in_addr inaddr_any = { INADDR_ANY }; 
     9+#endif 
     10 in_port_t g_udp_port = 161; 
     11 in_port_t g_tcp_port = 161; 
     12 int g_timeout = 1; 
    113--- a/mini_snmpd.c 
    214+++ b/mini_snmpd.c 
    3 @@ -90,9 +90,10 @@ 
     15@@ -90,9 +90,10 @@ static void handle_signal(int signo) 
    416  
    517 static void handle_udp_client(void) 
    618 { 
    719-       struct sockaddr_in sockaddr; 
    8 +       struct sockaddr_in6 sockaddr; 
     20+       struct my_sockaddr_t sockaddr; 
    921        socklen_t socklen; 
    1022        int rv; 
    11 +       char straddr[INET6_ADDRSTRLEN]; 
     23+       char straddr[my_inet_addrstrlen]; 
    1224  
    1325        /* Read the whole UDP packet from the socket at once */ 
    1426        socklen = sizeof (sockaddr); 
    15 @@ -105,8 +106,8 @@ 
     27@@ -105,22 +106,23 @@ static void handle_udp_client(void) 
    1628        } 
    1729        g_udp_client.timestamp = time(NULL); 
     
    1931-       g_udp_client.addr = sockaddr.sin_addr.s_addr; 
    2032-       g_udp_client.port = sockaddr.sin_port; 
    21 +       g_udp_client.addr = sockaddr.sin6_addr; 
    22 +       g_udp_client.port = sockaddr.sin6_port; 
     33+       g_udp_client.addr = sockaddr.my_sin_addr; 
     34+       g_udp_client.port = sockaddr.my_sin_port; 
    2335        g_udp_client.size = rv; 
    2436        g_udp_client.outgoing = 0; 
    2537 #ifdef DEBUG 
    26 @@ -114,13 +115,14 @@ 
     38        dump_packet(&g_udp_client); 
    2739 #endif 
     40+       inet_ntop(my_af_inet, &sockaddr.my_sin_addr, straddr, sizeof(straddr)); 
    2841  
    2942        /* Call the protocol handler which will prepare the response packet */ 
    30 +       inet_ntop(AF_INET6, &sockaddr.sin6_addr, straddr, sizeof(straddr)); 
    3143        if (snmp(&g_udp_client) == -1) { 
    3244                lprintf(LOG_WARNING, "could not handle packet from UDP client %s:%d: %m\n", 
    3345-                       inet_ntoa(sockaddr.sin_addr), sockaddr.sin_port); 
    34 +                       straddr, sockaddr.sin6_port); 
     46+                       straddr, sockaddr.my_sin_port); 
    3547                return; 
    3648        } else if (g_udp_client.size == 0) { 
    3749                lprintf(LOG_WARNING, "could not handle packet from UDP client %s:%d: ignored\n", 
    3850-                       inet_ntoa(sockaddr.sin_addr), sockaddr.sin_port); 
    39 +                       straddr, sockaddr.sin6_port); 
     51+                       straddr, sockaddr.my_sin_port); 
    4052                return; 
    4153        } 
    4254        g_udp_client.outgoing = 1; 
    43 @@ -128,13 +130,14 @@ 
    44         /* Send the whole UDP packet to the socket at once */ 
    45         rv = sendto(g_udp_sockfd, g_udp_client.packet, g_udp_client.size, 
     55@@ -130,11 +132,11 @@ static void handle_udp_client(void) 
    4656                MSG_DONTWAIT, (struct sockaddr *)&sockaddr, socklen); 
    47 +       inet_ntop(AF_INET6, &sockaddr.sin6_addr, straddr, sizeof(straddr)); 
    4857        if (rv == -1) { 
    4958                lprintf(LOG_WARNING, "could not send packet to UDP client %s:%d: %m\n", 
    5059-                       inet_ntoa(sockaddr.sin_addr), sockaddr.sin_port); 
    51 +                       straddr, sockaddr.sin6_port); 
     60+                       straddr, sockaddr.my_sin_port); 
    5261        } else if (rv != g_udp_client.size) { 
    5362                lprintf(LOG_WARNING, "could not send packet to UDP client %s:%d: " 
     
    5564-                       sockaddr.sin_port, rv, (int) g_udp_client.size); 
    5665+                       "only %d of %d bytes written\n", straddr, 
    57 +                       sockaddr.sin6_port, rv, (int) g_udp_client.size); 
     66+                       sockaddr.my_sin_port, rv, (int) g_udp_client.size); 
    5867        } 
    5968 #ifdef DEBUG 
    6069        dump_packet(&g_udp_client); 
    61 @@ -143,11 +146,12 @@ 
     70@@ -143,11 +145,12 @@ static void handle_udp_client(void) 
    6271  
    6372 static void handle_tcp_connect(void) 
     
    6574-       struct sockaddr_in tmp_sockaddr; 
    6675-       struct sockaddr_in sockaddr; 
    67 +       struct sockaddr_in6 tmp_sockaddr; 
    68 +       struct sockaddr_in6 sockaddr; 
     76+       struct my_sockaddr_t tmp_sockaddr; 
     77+       struct my_sockaddr_t sockaddr; 
    6978        socklen_t socklen; 
    7079        client_t *client; 
    7180        int rv; 
    72 +       char straddr[INET6_ADDRSTRLEN]; 
     81+       char straddr[my_inet_addrstrlen]; 
    7382  
    7483        /* Accept the new connection (remember the client's IP address and port) */ 
    7584        socklen = sizeof (sockaddr); 
    76 @@ -168,10 +172,11 @@ 
     85@@ -168,10 +171,11 @@ static void handle_tcp_connect(void) 
    7786                        lprintf(LOG_ERR, "could not accept TCP connection: internal error"); 
    7887                        exit(EXIT_SYSCALL); 
     
    8089-               tmp_sockaddr.sin_addr.s_addr = client->addr; 
    8190-               tmp_sockaddr.sin_port = client->port; 
    82 +               tmp_sockaddr.sin6_addr = client->addr; 
    83 +               tmp_sockaddr.sin6_port = client->port; 
    84 +               inet_ntop(AF_INET6, &tmp_sockaddr.sin6_addr, straddr, sizeof(straddr)); 
     91+               tmp_sockaddr.my_sin_addr = client->addr; 
     92+               tmp_sockaddr.my_sin_port = client->port; 
     93+               inet_ntop(my_af_inet, &tmp_sockaddr.my_sin_addr, straddr, sizeof(straddr)); 
    8594                lprintf(LOG_WARNING, "maximum number of %d clients reached, kicking out %s:%d\n", 
    8695-                       MAX_NR_CLIENTS, inet_ntoa(tmp_sockaddr.sin_addr), tmp_sockaddr.sin_port); 
    87 +                       MAX_NR_CLIENTS, straddr, tmp_sockaddr.sin6_port); 
     96+                       MAX_NR_CLIENTS, straddr, tmp_sockaddr.my_sin_port); 
    8897                close(client->sockfd); 
    8998        } else { 
    9099                client = malloc(sizeof (client_t)); 
    91 @@ -183,35 +188,38 @@ 
     100@@ -183,35 +187,38 @@ static void handle_tcp_connect(void) 
    92101        } 
    93102  
    94103        /* Now fill out the client control structure values */ 
    95 +       inet_ntop(AF_INET6, &sockaddr.sin6_addr, straddr, sizeof(straddr)); 
     104+       inet_ntop(my_af_inet, &sockaddr.my_sin_addr, straddr, sizeof(straddr)); 
    96105        lprintf(LOG_DEBUG, "connected TCP client %s:%d\n", 
    97106-               inet_ntoa(sockaddr.sin_addr), sockaddr.sin_port); 
    98 +               straddr, sockaddr.sin6_port); 
     107+               straddr, sockaddr.my_sin_port); 
    99108        client->timestamp = time(NULL); 
    100109        client->sockfd = rv; 
    101110-       client->addr = sockaddr.sin_addr.s_addr; 
    102111-       client->port = sockaddr.sin_port; 
    103 +       client->addr = sockaddr.sin6_addr; 
    104 +       client->port = sockaddr.sin6_port; 
     112+       client->addr = sockaddr.my_sin_addr; 
     113+       client->port = sockaddr.my_sin_port; 
    105114        client->size = 0; 
    106115        client->outgoing = 0; 
     
    110119 { 
    111120-       struct sockaddr_in sockaddr; 
    112 +       struct sockaddr_in6 sockaddr; 
     121+       struct my_sockaddr_t sockaddr; 
    113122        int rv; 
    114 +       char straddr[INET6_ADDRSTRLEN]; 
     123+       char straddr[my_inet_addrstrlen]; 
    115124  
    116125        /* Send the packet atomically and close socket if that did not work */ 
    117126-       sockaddr.sin_addr.s_addr = client->addr; 
    118127-       sockaddr.sin_port = client->port; 
    119 +       sockaddr.sin6_addr = client->addr; 
    120 +       sockaddr.sin6_port = client->port; 
     128+       sockaddr.my_sin_addr = client->addr; 
     129+       sockaddr.my_sin_port = client->port; 
    121130        rv = send(client->sockfd, client->packet, client->size, 0); 
    122 +       inet_ntop(AF_INET6, &sockaddr.sin6_addr, straddr, sizeof(straddr)); 
     131+       inet_ntop(my_af_inet, &sockaddr.my_sin_addr, straddr, sizeof(straddr)); 
    123132        if (rv == -1) { 
    124133                lprintf(LOG_WARNING, "could not send packet to TCP client %s:%d: %m\n", 
    125134-                       inet_ntoa(sockaddr.sin_addr), sockaddr.sin_port); 
    126 +                       straddr, sockaddr.sin6_port); 
     135+                       straddr, sockaddr.my_sin_port); 
    127136                close(client->sockfd); 
    128137                client->sockfd = -1; 
     
    133142-                       sockaddr.sin_port, rv, (int) client->size); 
    134143+                       "only %d of %d bytes written\n", straddr, 
    135 +                       sockaddr.sin6_port, rv, (int) client->size); 
    136                 close(client->sockfd); 
    137                 client->sockfd = -1; 
    138                 return; 
    139 @@ -227,23 +235,25 @@ 
     144+                       sockaddr.my_sin_port, rv, (int) client->size); 
     145                close(client->sockfd); 
     146                client->sockfd = -1; 
     147                return; 
     148@@ -227,23 +234,25 @@ static void handle_tcp_client_write(clie 
    140149  
    141150 static void handle_tcp_client_read(client_t *client) 
    142151 { 
    143152-       struct sockaddr_in sockaddr; 
    144 +       struct sockaddr_in6 sockaddr; 
     153+       struct my_sockaddr_t sockaddr; 
    145154        int rv; 
    146 +       char straddr[INET6_ADDRSTRLEN]; 
     155+       char straddr[my_inet_addrstrlen]; 
    147156  
    148157        /* Read from the socket what arrived and put it into the buffer */ 
    149158-       sockaddr.sin_addr.s_addr = client->addr; 
    150159-       sockaddr.sin_port = client->port; 
    151 +       sockaddr.sin6_addr = client->addr; 
    152 +       sockaddr.sin6_port = client->port; 
     160+       sockaddr.my_sin_addr = client->addr; 
     161+       sockaddr.my_sin_port = client->port; 
    153162        rv = read(client->sockfd, client->packet + client->size, 
    154163                sizeof (client->packet) - client->size); 
    155 +       inet_ntop(AF_INET6, &sockaddr.sin6_addr, straddr, sizeof(straddr)); 
     164+       inet_ntop(my_af_inet, &sockaddr.my_sin_addr, straddr, sizeof(straddr)); 
    156165        if (rv == -1) { 
    157166                lprintf(LOG_WARNING, "could not read packet from TCP client %s:%d: %m\n", 
    158167-                       inet_ntoa(sockaddr.sin_addr), sockaddr.sin_port); 
    159 +                       straddr, sockaddr.sin6_port); 
     168+                       straddr, sockaddr.my_sin_port); 
    160169                close(client->sockfd); 
    161170                client->sockfd = -1; 
     
    164173                lprintf(LOG_DEBUG, "disconnected TCP client %s:%d\n", 
    165174-                       inet_ntoa(sockaddr.sin_addr), sockaddr.sin_port); 
    166 +                       straddr, sockaddr.sin6_port); 
    167                 close(client->sockfd); 
    168                 client->sockfd = -1; 
    169                 return; 
    170 @@ -255,7 +265,7 @@ 
     175+                       straddr, sockaddr.my_sin_port); 
     176                close(client->sockfd); 
     177                client->sockfd = -1; 
     178                return; 
     179@@ -255,7 +264,7 @@ static void handle_tcp_client_read(clien 
    171180        rv = snmp_packet_complete(client); 
    172181        if (rv == -1) { 
    173182                lprintf(LOG_WARNING, "could not handle packet from TCP client %s:%d: %m\n", 
    174183-                       inet_ntoa(sockaddr.sin_addr), sockaddr.sin_port); 
    175 +                       straddr, sockaddr.sin6_port); 
    176                 close(client->sockfd); 
    177                 client->sockfd = -1; 
    178                 return; 
    179 @@ -270,13 +280,13 @@ 
     184+                       straddr, sockaddr.my_sin_port); 
     185                close(client->sockfd); 
     186                client->sockfd = -1; 
     187                return; 
     188@@ -270,13 +279,13 @@ static void handle_tcp_client_read(clien 
    180189        /* Call the protocol handler which will prepare the response packet */ 
    181190        if (snmp(client) == -1) { 
    182191                lprintf(LOG_WARNING, "could not handle packet from TCP client %s:%d: %m\n", 
    183192-                       inet_ntoa(sockaddr.sin_addr), sockaddr.sin_port); 
    184 +                       straddr, sockaddr.sin6_port); 
     193+                       straddr, sockaddr.my_sin_port); 
    185194                close(client->sockfd); 
    186195                client->sockfd = -1; 
     
    189198                lprintf(LOG_WARNING, "could not handle packet from TCP client %s:%d: ignored\n", 
    190199-                       inet_ntoa(sockaddr.sin_addr), sockaddr.sin_port); 
    191 +                       straddr, sockaddr.sin6_port); 
    192                 close(client->sockfd); 
    193                 client->sockfd = -1; 
    194                 return; 
    195 @@ -313,7 +323,7 @@ 
     200+                       straddr, sockaddr.my_sin_port); 
     201                close(client->sockfd); 
     202                client->sockfd = -1; 
     203                return; 
     204@@ -313,7 +322,7 @@ int main(int argc, char *argv[]) 
    196205        int option_index = 1; 
    197206        int c; 
    198207  
    199208-       struct sockaddr_in sockaddr; 
    200 +       struct sockaddr_in6 sockaddr; 
     209+       struct my_sockaddr_t sockaddr; 
    201210        socklen_t socklen; 
    202211        fd_set rfds; 
    203212        fd_set wfds; 
    204 @@ -399,14 +409,14 @@ 
     213@@ -399,14 +408,14 @@ int main(int argc, char *argv[]) 
    205214 #endif 
    206215  
    207216        /* Open the server's UDP port and prepare it for listening */ 
    208217-       g_udp_sockfd = socket(PF_INET, SOCK_DGRAM, 0); 
    209 +       g_udp_sockfd = socket(PF_INET6, SOCK_DGRAM, 0); 
     218+       g_udp_sockfd = socket(my_pf_inet, SOCK_DGRAM, 0); 
    210219        if (g_udp_sockfd == -1) { 
    211220                lprintf(LOG_ERR, "could not create UDP socket: %m\n"); 
     
    215224-       sockaddr.sin_port = htons(g_udp_port); 
    216225-       sockaddr.sin_addr.s_addr = INADDR_ANY; 
    217 +       sockaddr.sin6_family = AF_INET6; 
    218 +       sockaddr.sin6_port = htons(g_udp_port); 
    219 +       sockaddr.sin6_addr = in6addr_any; 
     226+       sockaddr.my_sin_family = my_af_inet; 
     227+       sockaddr.my_sin_port = htons(g_udp_port); 
     228+       sockaddr.my_sin_addr = my_inaddr_any; 
    220229        socklen = sizeof (sockaddr); 
    221230        if (bind(g_udp_sockfd, (struct sockaddr *)&sockaddr, socklen) == -1) { 
    222231                lprintf(LOG_ERR, "could not bind UDP socket to port %d: %m\n", g_udp_port); 
    223 @@ -414,7 +424,7 @@ 
     232@@ -414,7 +423,7 @@ int main(int argc, char *argv[]) 
    224233        } 
    225234  
    226235        /* Open the server's TCP port and prepare it for listening */ 
    227236-       g_tcp_sockfd = socket(PF_INET, SOCK_STREAM, 0); 
    228 +       g_tcp_sockfd = socket(PF_INET6, SOCK_STREAM, 0); 
     237+       g_tcp_sockfd = socket(my_pf_inet, SOCK_STREAM, 0); 
    229238        if (g_tcp_sockfd == -1) { 
    230239                lprintf(LOG_ERR, "could not create TCP socket: %m\n"); 
    231240                exit(EXIT_SYSCALL); 
    232 @@ -424,9 +434,9 @@ 
     241@@ -424,9 +433,9 @@ int main(int argc, char *argv[]) 
    233242                lprintf(LOG_WARNING, "could not set SO_REUSEADDR on TCP socket: %m\n"); 
    234243                exit(EXIT_SYSCALL); 
     
    237246-       sockaddr.sin_port = htons(g_tcp_port); 
    238247-       sockaddr.sin_addr.s_addr = INADDR_ANY; 
    239 +       sockaddr.sin6_family = AF_INET6; 
    240 +       sockaddr.sin6_port = htons(g_tcp_port); 
    241 +       sockaddr.sin6_addr = in6addr_any; 
     248+       sockaddr.my_sin_family = my_af_inet; 
     249+       sockaddr.my_sin_port = htons(g_tcp_port); 
     250+       sockaddr.my_sin_addr = my_inaddr_any; 
    242251        socklen = sizeof (sockaddr); 
    243252        if (bind(g_tcp_sockfd, (struct sockaddr *)&sockaddr, socklen) == -1) { 
     
    245254--- a/mini_snmpd.h 
    246255+++ b/mini_snmpd.h 
    247 @@ -129,7 +129,7 @@ 
     256@@ -120,6 +120,27 @@ 
     257        } while (0) 
     258 #endif 
     259  
     260+#ifdef IPV6 
     261+#define my_sockaddr_t          sockaddr_in6 
     262+#define my_sin_addr            sin6_addr 
     263+#define my_sin_port            sin6_port 
     264+#define my_sin_family          sin6_family 
     265+#define my_af_inet             AF_INET6 
     266+#define my_pf_inet             PF_INET6 
     267+#define my_in_addr_t           in6_addr 
     268+#define my_inaddr_any          in6addr_any 
     269+#define my_inet_addrstrlen     INET6_ADDRSTRLEN 
     270+#else 
     271+#define my_sockaddr_t          sockaddr_in 
     272+#define my_sin_addr            sin_addr 
     273+#define my_sin_port            sin_port 
     274+#define my_sin_family          sin_family 
     275+#define my_af_inet             AF_INET 
     276+#define my_pf_inet             PF_INET 
     277+#define my_in_addr_t           in_addr 
     278+#define my_inaddr_any          inaddr_any 
     279+#define my_inet_addrstrlen     INET_ADDRSTRLEN 
     280+#endif 
     281  
     282  
     283 /* ----------------------------------------------------------------------------- 
     284@@ -129,7 +150,7 @@ 
    248285 typedef struct client_s { 
    249286        time_t timestamp; 
    250287        int sockfd; 
    251288-       in_addr_t addr; 
    252 +       struct in6_addr addr; 
     289+       struct my_in_addr_t addr; 
    253290        in_port_t port; 
    254291        unsigned char packet[MAX_PACKET_SIZE]; 
    255292        size_t size; 
     293@@ -236,6 +257,9 @@ extern char *g_description; 
     294 extern char *g_vendor; 
     295 extern char *g_location; 
     296 extern char *g_contact; 
     297+#ifndef IPV6 
     298+extern const struct in_addr inaddr_any; 
     299+#endif 
     300 extern char *g_disk_list[MAX_NR_DISKS]; 
     301 extern int g_disk_list_length; 
     302 extern char *g_interface_list[MAX_NR_INTERFACES]; 
    256303--- a/utils.c 
    257304+++ b/utils.c 
    258 @@ -91,12 +91,13 @@ 
     305@@ -91,12 +91,13 @@ void read_values(const char *buffer, con 
    259306  
    260307 void dump_packet(const client_t *client) 
    261308 { 
    262309-       struct in_addr client_addr; 
    263 +       struct in6_addr client_addr; 
    264 +       char straddr[INET6_ADDRSTRLEN]; 
     310+       struct my_in_addr_t client_addr; 
     311+       char straddr[my_inet_addrstrlen]; 
    265312        char buffer[BUFSIZ]; 
    266313        int len; 
     
    272319        for (i = 0; i < client->size; i++) { 
    273320                len += snprintf(buffer + len, sizeof (buffer) - len, 
    274 @@ -105,9 +106,10 @@ 
     321@@ -105,9 +106,10 @@ void dump_packet(const client_t *client) 
    275322                        break; 
    276323                } 
    277324        } 
    278 +       inet_ntop(AF_INET6, &client_addr, straddr, sizeof(straddr)); 
     325+       inet_ntop(my_af_inet, &client_addr, straddr, sizeof(straddr)); 
    279326        lprintf(LOG_DEBUG, "%s %u bytes %s %s:%d (%s)\n", 
    280327                client->outgoing ? "transmitted" : "received", (int) client->size, 
Note: See TracChangeset for help on using the changeset viewer.