オープンソース・ソフトウェアの開発とダウンロード

TOMOYO

Subversion リポジトリの参照

/[tomoyo]/trunk/1.8.x/ccs-patch/security/ccsecurity/network.c

Diff of /trunk/1.8.x/ccs-patch/security/ccsecurity/network.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

branches/ccs-patch/security/ccsecurity/network.c revision 3825 by kumaneko, Sun Jul 18 06:37:11 2010 UTC trunk/1.8.x/ccs-patch/security/ccsecurity/network.c revision 3949 by kumaneko, Sun Sep 5 11:50:03 2010 UTC
# Line 3  Line 3 
3   *   *
4   * Copyright (C) 2005-2010  NTT DATA CORPORATION   * Copyright (C) 2005-2010  NTT DATA CORPORATION
5   *   *
6   * Version: 1.7.2+   2010/06/04   * Version: 1.8.0-pre   2010/09/01
7   *   *
8   * This file is applicable to both 2.4.30 and 2.6.11 and later.   * This file is applicable to both 2.4.30 and 2.6.11 and later.
9   * See README.ccs for ChangeLog.   * See README.ccs for ChangeLog.
# Line 14  Line 14 
14  #include <linux/inet.h>  #include <linux/inet.h>
15  #include <linux/in.h>  #include <linux/in.h>
16  #include <linux/in6.h>  #include <linux/in6.h>
17    #include <linux/un.h>
18    #include <net/sock.h>
19    #include <net/af_unix.h>
20  #include <net/ip.h>  #include <net/ip.h>
21  #include <net/ipv6.h>  #include <net/ipv6.h>
22  #include <net/udp.h>  #include <net/udp.h>
23  #include "internal.h"  #include "internal.h"
24    
25  const char *ccs_net_keyword[CCS_MAX_NETWORK_OPERATION] = {  struct ccs_inet_addr_info {
26          [CCS_NETWORK_UDP_BIND] = "UDP bind",          u16 port;           /* In network byte order. */
27          [CCS_NETWORK_UDP_CONNECT] = "UDP connect",          const u32 *address; /* In network byte order. */
28          [CCS_NETWORK_TCP_BIND] = "TCP bind",          bool is_ipv6;
29          [CCS_NETWORK_TCP_LISTEN] = "TCP listen",  };
30          [CCS_NETWORK_TCP_CONNECT] = "TCP connect",  
31          [CCS_NETWORK_TCP_ACCEPT] = "TCP accept",  struct ccs_unix_addr_info {
32          [CCS_NETWORK_RAW_BIND] = "RAW bind",          u8 *addr;
33          [CCS_NETWORK_RAW_CONNECT] = "RAW connect"          unsigned int addr_len;
34    };
35    
36    struct ccs_addr_info {
37            u8 protocol;
38            u8 operation;
39            struct ccs_inet_addr_info inet;
40            struct ccs_unix_addr_info unix0;
41    };
42    
43    const char *ccs_proto_keyword[CCS_SOCK_MAX] = {
44            [SOCK_STREAM]    = "stream",
45            [SOCK_DGRAM]     = "dgram",
46            [SOCK_RAW]       = "raw",
47            [SOCK_SEQPACKET] = "seqpacket",
48    };
49    
50    const char *ccs_socket_keyword[CCS_MAX_NETWORK_OPERATION] = {
51            [CCS_NETWORK_BIND]    = "bind",
52            [CCS_NETWORK_LISTEN]  = "listen",
53            [CCS_NETWORK_CONNECT] = "connect",
54            [CCS_NETWORK_ACCEPT]  = "accept",
55            [CCS_NETWORK_SEND]    = "send",
56            [CCS_NETWORK_RECV]    = "recv",
57  };  };
58    
59    static int ccs_audit_net_log(struct ccs_request_info *r, const char *family,
60                                 const u8 proto, const u8 ope, const char *address)
61    {
62            const char *protocol = ccs_proto_keyword[proto];
63            const char *operation = ccs_socket_keyword[ope];
64            ccs_write_log(r, "network %s %s %s %s\n", family,
65                          protocol, operation, address);
66            if (r->granted)
67                    return 0;
68            ccs_warn_log(r, "network %s %s %s %s", family, protocol, operation,
69                         address);
70            return ccs_supervisor(r, "network %s %s %s %s\n", family, protocol,
71                                  operation, address);
72    }
73    
74  /**  /**
75   * ccs_audit_network_log - Audit network log.   * ccs_audit_inet_log - Audit INET network log.
76   *   *
77   * @r: Pointer to "struct ccs_request_info".   * @r: Pointer to "struct ccs_request_info".
78   *   *
79   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
80   */   */
81  static int ccs_audit_network_log(struct ccs_request_info *r)  static int ccs_audit_inet_log(struct ccs_request_info *r)
82  {  {
83          char buf[128];          char buf[128];
84          const char *operation = ccs_net_keyword[r->param.network.operation];          int len;
85          const u32 *address = r->param.network.address;          const u32 *address = r->param.inet_network.address;
86          const u16 port = r->param.network.port;          if (r->param.inet_network.is_ipv6)
         if (r->param.network.is_ipv6)  
87                  ccs_print_ipv6(buf, sizeof(buf), (const struct in6_addr *)                  ccs_print_ipv6(buf, sizeof(buf), (const struct in6_addr *)
88                                 address, (const struct in6_addr *) address);                                 address, (const struct in6_addr *) address);
89          else          else
90                  ccs_print_ipv4(buf, sizeof(buf), r->param.network.ip,                  ccs_print_ipv4(buf, sizeof(buf), r->param.inet_network.ip,
91                                 r->param.network.ip);                                 r->param.inet_network.ip);
92          ccs_write_log(r, "network %s %s %u\n", operation, buf, port);          len = strlen(buf);
93          if (r->granted)          snprintf(buf + len, sizeof(buf) - len, " %u",
94                  return 0;                   r->param.inet_network.port);
95          ccs_warn_log(r, "network %s %s %u", operation, buf, port);          return ccs_audit_net_log(r, "inet", r->param.inet_network.protocol,
96          return ccs_supervisor(r, "network %s %s %u\n", operation, buf, port);                                   r->param.inet_network.operation, buf);
97    }
98    
99    /**
100     * ccs_audit_unix_log - Audit UNIX network log.
101     *
102     * @r: Pointer to "struct ccs_request_info".
103     *
104     * Returns 0 on success, negative value otherwise.
105     */
106    static int ccs_audit_unix_log(struct ccs_request_info *r)
107    {
108            return ccs_audit_net_log(r, "unix", r->param.unix_network.protocol,
109                                     r->param.unix_network.operation,
110                                     r->param.unix_network.address->name);
111  }  }
112    
113  /**  /**
# Line 150  void ccs_print_ipv6(char *buffer, const Line 204  void ccs_print_ipv6(char *buffer, const
204                   NIP6(*max_ip));                   NIP6(*max_ip));
205  }  }
206    
207  static bool ccs_check_network_acl(const struct ccs_request_info *r,  static bool ccs_check_inet_acl(struct ccs_request_info *r,
208                                    const struct ccs_acl_info *ptr)                                 const struct ccs_acl_info *ptr)
209  {  {
210          const struct ccs_ip_network_acl *acl =          const struct ccs_inet_acl *acl = container_of(ptr, typeof(*acl), head);
                 container_of(ptr, typeof(*acl), head);  
211          bool ret;          bool ret;
212          if (!(acl->perm & (1 << r->param.network.operation)) ||          if (!(acl->perm & (1 << r->param.inet_network.operation)) ||
213              !ccs_compare_number_union(r->param.network.port, &acl->port))              !ccs_compare_number_union(r->param.inet_network.port, &acl->port))
214                  return false;                  return false;
215          switch (acl->address_type) {          switch (acl->address_type) {
216          case CCS_IP_ADDRESS_TYPE_ADDRESS_GROUP:          case CCS_IP_ADDRESS_TYPE_ADDRESS_GROUP:
217                  ret = ccs_address_matches_group(r->param.network.is_ipv6,                  ret = ccs_address_matches_group(r->param.inet_network.is_ipv6,
218                                                  r->param.network.address,                                                  r->param.inet_network.address,
219                                                  acl->address.group);                                                  acl->address.group);
220                  break;                  break;
221          case CCS_IP_ADDRESS_TYPE_IPv4:          case CCS_IP_ADDRESS_TYPE_IPv4:
222                  ret = !r->param.network.is_ipv6 &&                  ret = !r->param.inet_network.is_ipv6 &&
223                          acl->address.ipv4.min <= r->param.network.ip &&                          acl->address.ipv4.min <= r->param.inet_network.ip &&
224                          r->param.network.ip <= acl->address.ipv4.max;                          r->param.inet_network.ip <= acl->address.ipv4.max;
225                  break;                  break;
226          default:          default:
227                  ret = r->param.network.is_ipv6 &&                  ret = r->param.inet_network.is_ipv6 &&
228                          memcmp(acl->address.ipv6.min, r->param.network.address,                          memcmp(acl->address.ipv6.min,
229                                 16) <= 0 &&                                 r->param.inet_network.address, 16) <= 0 &&
230                          memcmp(r->param.network.address, acl->address.ipv6.max,                          memcmp(r->param.inet_network.address,
231                                 16) <= 0;                                 acl->address.ipv6.max, 16) <= 0;
232                  break;                  break;
233          }          }
234          return ret;          return ret;
235  }  }
236    
237  /**  static bool ccs_check_unix_acl(struct ccs_request_info *r,
238   * ccs_network_entry - Check permission for network operation.                                 const struct ccs_acl_info *ptr)
  *  
  * @is_ipv6:   True if @address is an IPv6 address.  
  * @operation: Type of operation.  
  * @address:   An IPv4 or IPv6 address in network byte order.  
  * @port:      Port number in network byte order.  
  *  
  * Returns 0 on success, negative value otherwise.  
  */  
 static int ccs_network_entry(const bool is_ipv6, const u8 operation,  
                              const u32 *address, const u16 port)  
239  {  {
240          const int idx = ccs_read_lock();          const struct ccs_unix_acl *acl = container_of(ptr, typeof(*acl), head);
241          struct ccs_request_info r;          return (acl->perm & (1 << r->param.unix_network.operation)) &&
242          int error = 0;                  ccs_compare_name_union(r->param.unix_network.address,
243          if (ccs_init_request_info(&r, CCS_MAC_NETWORK_UDP_BIND + operation)                                         &acl->name);
244              != CCS_CONFIG_DISABLED) {  }
245                  r.param_type = CCS_TYPE_IP_NETWORK_ACL;  
246                  r.param.network.operation = operation;  static const u8
247                  r.param.network.is_ipv6 = is_ipv6;  ccs_inet2mac[CCS_SOCK_MAX][CCS_MAX_NETWORK_OPERATION] = {
248                  r.param.network.address = address;          [SOCK_STREAM] = {
249                  r.param.network.port = ntohs(port);                  [CCS_NETWORK_BIND]    = CCS_MAC_NETWORK_INET_STREAM_BIND,
250                  /* use host byte order to allow u32 comparison than memcmp().*/                  [CCS_NETWORK_LISTEN]  = CCS_MAC_NETWORK_INET_STREAM_LISTEN,
251                  r.param.network.ip = ntohl(*address);                  [CCS_NETWORK_CONNECT] = CCS_MAC_NETWORK_INET_STREAM_CONNECT,
252                  do {                  [CCS_NETWORK_ACCEPT]  = CCS_MAC_NETWORK_INET_STREAM_ACCEPT,
253                          ccs_check_acl(&r, ccs_check_network_acl);          },
254                          error = ccs_audit_network_log(&r);          [SOCK_DGRAM] = {
255                  } while (error == CCS_RETRY_REQUEST);                  [CCS_NETWORK_BIND]    = CCS_MAC_NETWORK_INET_DGRAM_BIND,
256          }                  [CCS_NETWORK_SEND]    = CCS_MAC_NETWORK_INET_DGRAM_SEND,
257          ccs_read_unlock(idx);                  [CCS_NETWORK_RECV]    = CCS_MAC_NETWORK_INET_DGRAM_RECV,
258          return error;          },
259  }          [SOCK_RAW]    = {
260                    [CCS_NETWORK_BIND]    = CCS_MAC_NETWORK_INET_RAW_BIND,
261                    [CCS_NETWORK_SEND]    = CCS_MAC_NETWORK_INET_RAW_SEND,
262                    [CCS_NETWORK_RECV]    = CCS_MAC_NETWORK_INET_RAW_RECV,
263            },
264    };
265    
266    static const u8
267    ccs_unix2mac[CCS_SOCK_MAX][CCS_MAX_NETWORK_OPERATION] = {
268            [SOCK_STREAM] = {
269                    [CCS_NETWORK_BIND]    = CCS_MAC_NETWORK_UNIX_STREAM_BIND,
270                    [CCS_NETWORK_LISTEN]  = CCS_MAC_NETWORK_UNIX_STREAM_LISTEN,
271                    [CCS_NETWORK_CONNECT] = CCS_MAC_NETWORK_UNIX_STREAM_CONNECT,
272                    [CCS_NETWORK_ACCEPT]  = CCS_MAC_NETWORK_UNIX_STREAM_ACCEPT,
273            },
274            [SOCK_DGRAM] = {
275                    [CCS_NETWORK_BIND]    = CCS_MAC_NETWORK_UNIX_DGRAM_BIND,
276                    [CCS_NETWORK_SEND]    = CCS_MAC_NETWORK_UNIX_DGRAM_SEND,
277                    [CCS_NETWORK_RECV]    = CCS_MAC_NETWORK_UNIX_DGRAM_RECV,
278            },
279            [SOCK_SEQPACKET] = {
280                    [CCS_NETWORK_BIND]    = CCS_MAC_NETWORK_UNIX_SEQPACKET_BIND,
281                    [CCS_NETWORK_LISTEN]  = CCS_MAC_NETWORK_UNIX_SEQPACKET_LISTEN,
282                    [CCS_NETWORK_CONNECT] = CCS_MAC_NETWORK_UNIX_SEQPACKET_CONNECT,
283                    [CCS_NETWORK_ACCEPT]  = CCS_MAC_NETWORK_UNIX_SEQPACKET_ACCEPT,
284            },
285    };
286    
287  static bool ccs_same_ip_network_acl(const struct ccs_acl_info *a,  static bool ccs_same_inet_acl(const struct ccs_acl_info *a,
288                                      const struct ccs_acl_info *b)                                        const struct ccs_acl_info *b)
289  {  {
290          const struct ccs_ip_network_acl *p1 = container_of(a, typeof(*p1),          const struct ccs_inet_acl *p1 = container_of(a, typeof(*p1), head);
291                                                             head);          const struct ccs_inet_acl *p2 = container_of(b, typeof(*p2), head);
292          const struct ccs_ip_network_acl *p2 = container_of(b, typeof(*p2),          return p1->protocol == p2->protocol &&
293                                                             head);                  p1->address_type == p2->address_type &&
         return ccs_same_acl_head(&p1->head, &p2->head)  
                 && p1->address_type == p2->address_type &&  
294                  p1->address.ipv4.min == p2->address.ipv4.min &&                  p1->address.ipv4.min == p2->address.ipv4.min &&
295                  p1->address.ipv6.min == p2->address.ipv6.min &&                  p1->address.ipv6.min == p2->address.ipv6.min &&
296                  p1->address.ipv4.max == p2->address.ipv4.max &&                  p1->address.ipv4.max == p2->address.ipv4.max &&
# Line 232  static bool ccs_same_ip_network_acl(cons Line 299  static bool ccs_same_ip_network_acl(cons
299                  ccs_same_number_union(&p1->port, &p2->port);                  ccs_same_number_union(&p1->port, &p2->port);
300  }  }
301    
302  static bool ccs_merge_ip_network_acl(struct ccs_acl_info *a,  static bool ccs_same_unix_acl(const struct ccs_acl_info *a,
303                                       struct ccs_acl_info *b,                                        const struct ccs_acl_info *b)
304                                       const bool is_delete)  {
305            const struct ccs_unix_acl *p1 = container_of(a, typeof(*p1), head);
306            const struct ccs_unix_acl *p2 = container_of(b, typeof(*p2), head);
307            return p1->protocol == p2->protocol &&
308                    ccs_same_name_union(&p1->name, &p2->name);
309    }
310    
311    static bool ccs_merge_inet_acl(struct ccs_acl_info *a, struct ccs_acl_info *b,
312                                   const bool is_delete)
313    {
314            u8 * const a_perm = &container_of(a, struct ccs_inet_acl, head)->perm;
315            u8 perm = *a_perm;
316            const u8 b_perm = container_of(b, struct ccs_inet_acl, head)->perm;
317            if (is_delete)
318                    perm &= ~b_perm;
319            else
320                    perm |= b_perm;
321            *a_perm = perm;
322            return !perm;
323    }
324    
325    static bool ccs_merge_unix_acl(struct ccs_acl_info *a, struct ccs_acl_info *b,
326                                   const bool is_delete)
327  {  {
328          u8 * const a_perm = &container_of(a, struct ccs_ip_network_acl, head)          u8 * const a_perm = &container_of(a, struct ccs_unix_acl, head)->perm;
                 ->perm;  
329          u8 perm = *a_perm;          u8 perm = *a_perm;
330          const u8 b_perm = container_of(b, struct ccs_ip_network_acl, head)          const u8 b_perm = container_of(b, struct ccs_unix_acl, head)->perm;
                 ->perm;  
331          if (is_delete)          if (is_delete)
332                  perm &= ~b_perm;                  perm &= ~b_perm;
333          else          else
# Line 250  static bool ccs_merge_ip_network_acl(str Line 337  static bool ccs_merge_ip_network_acl(str
337  }  }
338    
339  /**  /**
340   * ccs_write_network - Write "struct ccs_ip_network_acl" list.   * ccs_write_inet_network - Write "struct ccs_inet_acl" list.
341   *   *
342   * @data:      String to parse.   * @data:  String to parse.
343   * @domain:    Pointer to "struct ccs_domain_info".   * @param: Pointer to "struct ccs_acl_param".
  * @condition: Pointer to "struct ccs_condition". Maybe NULL.  
  * @is_delete: True if it is a delete request.  
344   *   *
345   * Returns 0 on success, negative value otherwise.   * Returns 0 on success, negative value otherwise.
346   */   */
347  int ccs_write_network(char *data, struct ccs_domain_info *domain,  int ccs_write_inet_network(char *data, struct ccs_acl_param *param)
                       struct ccs_condition *condition, const bool is_delete)  
348  {  {
349          struct ccs_ip_network_acl e = {          struct ccs_inet_acl e = { .head.type = CCS_TYPE_INET_ACL };
                 .head.type = CCS_TYPE_IP_NETWORK_ACL,  
                 .head.cond = condition,  
         };  
350          u16 min_address[8];          u16 min_address[8];
351          u16 max_address[8];          u16 max_address[8];
352          int error = is_delete ? -ENOENT : -ENOMEM;          int error = -EINVAL;
353          u8 sock_type;          u8 type;
354          u8 operation;          if (!ccs_tokenize(data, param->w, sizeof(param->w)) || !param->w[3][0])
         char *w[4];  
         if (!ccs_tokenize(data, w, sizeof(w)) || !w[3][0])  
                 return -EINVAL;  
         if (!strcmp(w[0], "TCP"))  
                 sock_type = SOCK_STREAM;  
         else if (!strcmp(w[0], "UDP"))  
                 sock_type = SOCK_DGRAM;  
         else if (!strcmp(w[0], "RAW"))  
                 sock_type = SOCK_RAW;  
         else  
355                  return -EINVAL;                  return -EINVAL;
356          if (!strcmp(w[1], "bind"))          for (e.protocol = 0; e.protocol < CCS_SOCK_MAX; e.protocol++)
357                  switch (sock_type) {                  if (!strcmp(param->w[0], ccs_proto_keyword[e.protocol]))
                 case SOCK_STREAM:  
                         operation = CCS_NETWORK_TCP_BIND;  
                         break;  
                 case SOCK_DGRAM:  
                         operation = CCS_NETWORK_UDP_BIND;  
                         break;  
                 default:  
                         operation = CCS_NETWORK_RAW_BIND;  
                         break;  
                 }  
         else if (!strcmp(w[1], "connect"))  
                 switch (sock_type) {  
                 case SOCK_STREAM:  
                         operation = CCS_NETWORK_TCP_CONNECT;  
                         break;  
                 case SOCK_DGRAM:  
                         operation = CCS_NETWORK_UDP_CONNECT;  
                         break;  
                 default:  
                         operation = CCS_NETWORK_RAW_CONNECT;  
358                          break;                          break;
359                  }          for (type = 0; type < CCS_MAX_NETWORK_OPERATION; type++)
360          else if (sock_type == SOCK_STREAM && !strcmp(w[1], "listen"))                  if (ccs_permstr(param->w[1], ccs_socket_keyword[type]))
361                  operation = CCS_NETWORK_TCP_LISTEN;                          e.perm |= 1 << type;
362          else if (sock_type == SOCK_STREAM && !strcmp(w[1], "accept"))          if (e.protocol == CCS_SOCK_MAX || !e.perm)
                 operation = CCS_NETWORK_TCP_ACCEPT;  
         else  
363                  return -EINVAL;                  return -EINVAL;
364          e.perm = 1 << operation;                                  switch (ccs_parse_ip_address(param->w[2], min_address, max_address)) {
         switch (ccs_parse_ip_address(w[2], min_address, max_address)) {  
365          case CCS_IP_ADDRESS_TYPE_IPv6:          case CCS_IP_ADDRESS_TYPE_IPv6:
366                  e.address_type = CCS_IP_ADDRESS_TYPE_IPv6;                  e.address_type = CCS_IP_ADDRESS_TYPE_IPv6;
367                  e.address.ipv6.min = ccs_get_ipv6_address((struct in6_addr *)                  e.address.ipv6.min = ccs_get_ipv6_address((struct in6_addr *)
368                                                            min_address);                                                              min_address);
369                  e.address.ipv6.max = ccs_get_ipv6_address((struct in6_addr *)                  e.address.ipv6.max = ccs_get_ipv6_address((struct in6_addr *)
370                                                            max_address);                                                              max_address);
371                  if (!e.address.ipv6.min || !e.address.ipv6.max)                  if (!e.address.ipv6.min || !e.address.ipv6.max)
372                          goto out;                          goto out;
373                  break;                  break;
# Line 330  int ccs_write_network(char *data, struct Line 378  int ccs_write_network(char *data, struct
378                  e.address.ipv4.max = ntohl(*(u32 *) max_address);                  e.address.ipv4.max = ntohl(*(u32 *) max_address);
379                  break;                  break;
380          default:          default:
381                  if (w[2][0] != '@')                  if (param->w[2][0] != '@')
382                          return -EINVAL;                          return -EINVAL;
383                  e.address_type = CCS_IP_ADDRESS_TYPE_ADDRESS_GROUP;                  e.address_type = CCS_IP_ADDRESS_TYPE_ADDRESS_GROUP;
384                  e.address.group = ccs_get_group(w[2] + 1, CCS_ADDRESS_GROUP);                  e.address.group = ccs_get_group(param->w[2] + 1,
385                                                    CCS_ADDRESS_GROUP);
386                  if (!e.address.group)                  if (!e.address.group)
387                          return -ENOMEM;                          return -ENOMEM;
388                  break;                  break;
389          }          }
390          if (!ccs_parse_number_union(w[3], &e.port))          if (!ccs_parse_number_union(param->w[3], &e.port))
391                  goto out;                  goto out;
392          error = ccs_update_domain(&e.head, sizeof(e), is_delete, domain,          error = ccs_update_domain(&e.head, sizeof(e), param, ccs_same_inet_acl,
393                                    ccs_same_ip_network_acl,                                    ccs_merge_inet_acl);
                                   ccs_merge_ip_network_acl);  
394   out:   out:
395          if (e.address_type == CCS_IP_ADDRESS_TYPE_ADDRESS_GROUP)          if (e.address_type == CCS_IP_ADDRESS_TYPE_ADDRESS_GROUP)
396                  ccs_put_group(e.address.group);                  ccs_put_group(e.address.group);
# Line 354  int ccs_write_network(char *data, struct Line 402  int ccs_write_network(char *data, struct
402          return error;          return error;
403  }  }
404    
405    /**
406     * ccs_write_unix_network - Write "struct ccs_unix_acl" list.
407     *
408     * @data:  String to parse.
409     * @param: Pointer to "struct ccs_acl_param".
410     *
411     * Returns 0 on success, negative value otherwise.
412     */
413    int ccs_write_unix_network(char *data, struct ccs_acl_param *param)
414    {
415            struct ccs_unix_acl e = { .head.type = CCS_TYPE_UNIX_ACL };
416            int error;
417            u8 type;
418            if (!ccs_tokenize(data, param->w, sizeof(param->w)) || !param->w[2][0])
419                    return -EINVAL;
420            for (e.protocol = 0; e.protocol < CCS_SOCK_MAX; e.protocol++)
421                    if (!strcmp(param->w[0], ccs_proto_keyword[e.protocol]))
422                            break;
423            for (type = 0; type < CCS_MAX_NETWORK_OPERATION; type++)
424                    if (ccs_permstr(param->w[1], ccs_socket_keyword[type]))
425                            e.perm |= 1 << type;
426            if (e.protocol == CCS_SOCK_MAX || !e.perm)
427                    return -EINVAL;
428            if (!ccs_parse_name_union(param->w[2], &e.name))
429                    return -EINVAL;
430            error = ccs_update_domain(&e.head, sizeof(e), param, ccs_same_unix_acl,
431                                      ccs_merge_unix_acl);
432            ccs_put_name_union(&e.name);
433            return error;
434    }
435    
436  #ifndef CONFIG_NET  #ifndef CONFIG_NET
437    
438  void __init ccs_network_init(void)  void __init ccs_network_init(void)
439  {  {
440            u8 i;
441            for (i = 0; i < CCS_SOCK_MAX; i++)
442                    if (!ccs_proto_keyword[i])
443                            ccs_proto_keyword[i] = "unknown";
444  }  }
445    
446  #else  #else
447    
448  #define MAX_SOCK_ADDR 128 /* net/socket.c */  /**
449     * ccs_inet_entry - Check permission for INET network operation.
450  /* Check permission for creating a socket. */   *
451  static int __ccs_socket_create_permission(int family, int type, int protocol)   * @address: Pointer to "struct ccs_addr_info".
452     *
453     * Returns 0 on success, negative value otherwise.
454     */
455    static int ccs_inet_entry(const struct ccs_addr_info *address)
456  {  {
457            const int idx = ccs_read_lock();
458            struct ccs_request_info r;
459          int error = 0;          int error = 0;
460          /* Nothing to do if I am a kernel service. */          const u8 type = ccs_inet2mac[address->protocol][address->operation];
461          if (segment_eq(get_fs(), KERNEL_DS))          if (type && ccs_init_request_info(&r, type) != CCS_CONFIG_DISABLED) {
462                  return 0;                  struct task_struct * const task = current;
463          if (family == PF_PACKET && !ccs_capable(CCS_USE_PACKET_SOCKET))                  const bool no_sleep = address->operation == CCS_NETWORK_ACCEPT
464                  return -EPERM;                          || address->operation == CCS_NETWORK_RECV;
465          if (family == PF_ROUTE && !ccs_capable(CCS_USE_ROUTE_SOCKET))                  r.param_type = CCS_TYPE_INET_ACL;
466                  return -EPERM;                  r.param.inet_network.protocol = address->protocol;
467          if (family != PF_INET && family != PF_INET6)                  r.param.inet_network.operation = address->operation;
468                  return 0;                  r.param.inet_network.is_ipv6 = address->inet.is_ipv6;
469          switch (type) {                  r.param.inet_network.address = address->inet.address;
470          case SOCK_STREAM:                  r.param.inet_network.port = ntohs(address->inet.port);
471                  if (!ccs_capable(CCS_INET_STREAM_SOCKET_CREATE))                  /* use host byte order to allow u32 comparison than memcmp().*/
472                          error = -EPERM;                  r.param.inet_network.ip = ntohl(*address->inet.address);
473                  break;                  if (no_sleep)
474          case SOCK_DGRAM:                          task->ccs_flags |= CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
475                  if (!ccs_capable(CCS_USE_INET_DGRAM_SOCKET))                  do {
476                          error = -EPERM;                          ccs_check_acl(&r, ccs_check_inet_acl);
477                            error = ccs_audit_inet_log(&r);
478                    } while (error == CCS_RETRY_REQUEST);
479                    if (no_sleep)
480                            task->ccs_flags &= ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
481            }
482            ccs_read_unlock(idx);
483            return error;
484    }
485    
486    static int ccs_check_inet_address(const struct sockaddr *addr,
487                                      const unsigned int addr_len, const u16 port,
488                                      struct ccs_addr_info *address)
489    {
490            struct ccs_inet_addr_info *i = &address->inet;
491            switch (addr->sa_family) {
492            case AF_INET6:
493                    if (addr_len < SIN6_LEN_RFC2133)
494                            goto skip;
495                    i->is_ipv6 = true;
496                    i->address = (u32 *)
497                            ((struct sockaddr_in6 *) addr)->sin6_addr.s6_addr;
498                    i->port = ((struct sockaddr_in6 *) addr)->sin6_port;
499                  break;                  break;
500          case SOCK_RAW:          case AF_INET:
501                  if (!ccs_capable(CCS_USE_INET_RAW_SOCKET))                  if (addr_len < sizeof(struct sockaddr_in))
502                          error = -EPERM;                          goto skip;
503                    i->is_ipv6 = false;
504                    i->address = (u32 *) &((struct sockaddr_in *) addr)->sin_addr;
505                    i->port = ((struct sockaddr_in *) addr)->sin_port;
506                  break;                  break;
507            default:
508                    goto skip;
509          }          }
510          return error;          if (address->protocol == SOCK_RAW)
511                    i->port = htons(port);
512            return ccs_inet_entry(address);
513     skip:
514            return 0;
515  }  }
516    
517  /* Check permission for listening a TCP socket. */  /**
518  static int __ccs_socket_listen_permission(struct socket *sock)   * ccs_unix_entry - Check permission for UNIX network operation.
519     *
520     * @address: Pointer to "struct ccs_addr_info".
521     *
522     * Returns 0 on success, negative value otherwise.
523     */
524    static int ccs_unix_entry(const struct ccs_addr_info *address)
525  {  {
526            const int idx = ccs_read_lock();
527            struct ccs_request_info r;
528          int error = 0;          int error = 0;
529          char addr[MAX_SOCK_ADDR];          const u8 type = ccs_unix2mac[address->protocol][address->operation];
530          int addr_len;          if (type && ccs_init_request_info(&r, type) != CCS_CONFIG_DISABLED) {
531          u32 *address;                  char *buf;
532          u16 port;                  if (address->unix0.addr_len <= sizeof(sa_family_t))
533          bool is_ipv6;                          buf = ccs_encode2("anonymous", 9);                      
534                    else if (address->unix0.addr[0])
535                            buf = ccs_encode(address->unix0.addr);
536                    else
537                            buf = ccs_encode2(address->unix0.addr,
538                                              address->unix0.addr_len
539                                              - sizeof(sa_family_t));
540                    if (buf) {
541                            struct task_struct * const task = current;
542                            const bool no_sleep =
543                                    address->operation == CCS_NETWORK_ACCEPT ||
544                                    address->operation == CCS_NETWORK_RECV;
545                            struct ccs_path_info addr;
546                            addr.name = buf;
547                            ccs_fill_path_info(&addr);
548                            r.param_type = CCS_TYPE_UNIX_ACL;
549                            r.param.unix_network.protocol = address->protocol;
550                            r.param.unix_network.operation = address->operation;
551                            r.param.unix_network.address = &addr;
552                            if (no_sleep)
553                                    task->ccs_flags |=
554                                            CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
555                    
556                            do {
557                                    ccs_check_acl(&r, ccs_check_unix_acl);
558                                    error = ccs_audit_unix_log(&r);
559                            } while (error == CCS_RETRY_REQUEST);
560                            if (no_sleep)
561                                    task->ccs_flags &=
562                                            ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;
563                            kfree(buf);
564                    } else
565                            error = -ENOMEM;
566            }
567            ccs_read_unlock(idx);
568            return error;
569    }
570    
571    static int ccs_check_unix_address(struct sockaddr *addr,
572                                      const unsigned int addr_len,
573                                      struct ccs_addr_info *address)
574    {
575            struct ccs_unix_addr_info *u = &address->unix0;
576            if (addr->sa_family != AF_UNIX)
577                    return 0;
578            u->addr = ((struct sockaddr_un *) addr)->sun_path;
579            u->addr_len = addr_len;
580            /*
581             * Terminate pathname with '\0' like unix_mkname() does.
582             * This is needed because pathname was copied by move_addr_to_kernel()
583             * but not yet terminated by unix_mkname().
584             */
585            if (u->addr[0] && addr_len > sizeof(short) &&
586                addr_len <= sizeof(struct sockaddr_un))
587                    ((char *) u->addr)[addr_len] = '\0';
588            return ccs_unix_entry(address);
589    }
590    
591    static bool ccs_kernel_service(void)
592    {
593          /* Nothing to do if I am a kernel service. */          /* Nothing to do if I am a kernel service. */
594          if (segment_eq(get_fs(), KERNEL_DS))          return segment_eq(get_fs(), KERNEL_DS);
595                  return 0;  }
596          if (sock->type != SOCK_STREAM)  
597    static u8 ccs_sock_family(struct sock *sk)
598    {
599            u8 family;
600            if (ccs_kernel_service())
601                  return 0;                  return 0;
602          switch (sock->sk->sk_family) {          family = sk->sk_family;
603            switch (family) {
604          case PF_INET:          case PF_INET:
605          case PF_INET6:          case PF_INET6:
606                  break;          case PF_UNIX:
607                    return family;
608          default:          default:
609                  return 0;                  return 0;
610          }          }
611          if (!ccs_capable(CCS_INET_STREAM_SOCKET_LISTEN))  }
612    
613    /* Check permission for creating a socket. */
614    static int __ccs_socket_create_permission(int family, int type, int protocol)
615    {
616            if (ccs_kernel_service())
617                    return 0;
618            if (family == PF_PACKET && !ccs_capable(CCS_USE_PACKET_SOCKET))
619                  return -EPERM;                  return -EPERM;
620          if (sock->ops->getname(sock, (struct sockaddr *) addr, &addr_len, 0))          if (family == PF_ROUTE && !ccs_capable(CCS_USE_ROUTE_SOCKET))
621                  return -EPERM;                  return -EPERM;
622          switch (((struct sockaddr *) addr)->sa_family) {          return 0;
623          case AF_INET6:  }
624                  is_ipv6 = true;  
625                  address = (u32 *) ((struct sockaddr_in6 *) addr)->sin6_addr  /* Check permission for listening a socket. */
626                          .s6_addr;  static int __ccs_socket_listen_permission(struct socket *sock)
627                  port = ((struct sockaddr_in6 *) addr)->sin6_port;  {
628                  break;          struct ccs_addr_info address;
629          case AF_INET:          const u8 family = ccs_sock_family(sock->sk);
630                  is_ipv6 = false;          const unsigned int type = sock->type;
631                  address = (u32 *) &((struct sockaddr_in *) addr)->sin_addr;          struct sockaddr_storage addr;
632                  port = ((struct sockaddr_in *) addr)->sin_port;          int addr_len;
633                  break;          if (!family || (type != SOCK_STREAM && type != SOCK_SEQPACKET))
634          default:                  return 0;
635                  goto skip;          {
636          }                  const int error = sock->ops->getname(sock, (struct sockaddr *)
637          error = ccs_network_entry(is_ipv6, CCS_NETWORK_TCP_LISTEN, address,                                                       &addr, &addr_len, 0);
638                                    port);                  if (error)
639   skip:                          return error;
640          return error;          }
641            address.protocol = type;
642            address.operation = CCS_NETWORK_LISTEN;
643            if (family == PF_UNIX)
644                    return ccs_check_unix_address((struct sockaddr *) &addr,
645                                                  addr_len, &address);
646            return ccs_check_inet_address((struct sockaddr *) &addr, addr_len, 0,
647                                          &address);
648  }  }
649    
650  /* Check permission for setting the remote IP address/port pair of a socket. */  /* Check permission for setting the remote address of a socket. */
651  static int __ccs_socket_connect_permission(struct socket *sock,  static int __ccs_socket_connect_permission(struct socket *sock,
652                                             struct sockaddr *addr, int addr_len)                                             struct sockaddr *addr, int addr_len)
653  {  {
654          int error = 0;          struct ccs_addr_info address;
655            const u8 family = ccs_sock_family(sock->sk);
656          const unsigned int type = sock->type;          const unsigned int type = sock->type;
657          u32 *address;          if (!family)
         u16 port;  
         u8 operation;  
         bool is_ipv6;  
         /* Nothing to do if I am a kernel service. */  
         if (segment_eq(get_fs(), KERNEL_DS))  
658                  return 0;                  return 0;
659            address.protocol = type;
660          switch (type) {          switch (type) {
         case SOCK_STREAM:  
                 operation = CCS_NETWORK_TCP_CONNECT;  
                 break;  
661          case SOCK_DGRAM:          case SOCK_DGRAM:
                 operation = CCS_NETWORK_UDP_CONNECT;  
                 break;  
662          case SOCK_RAW:          case SOCK_RAW:
663                  operation = CCS_NETWORK_RAW_CONNECT;                  address.operation = CCS_NETWORK_SEND;
664                  break;                  break;
665          default:          case SOCK_STREAM:
666                  return 0;          case SOCK_SEQPACKET:
667          }                  address.operation = CCS_NETWORK_CONNECT;
         switch (addr->sa_family) {  
         case AF_INET6:  
                 if (addr_len < SIN6_LEN_RFC2133)  
                         goto skip;  
                 is_ipv6 = true;  
                 address = (u32 *) ((struct sockaddr_in6 *) addr)->sin6_addr  
                         .s6_addr;  
                 port = ((struct sockaddr_in6 *) addr)->sin6_port;  
                 break;  
         case AF_INET:  
                 if (addr_len < sizeof(struct sockaddr_in))  
                         goto skip;  
                 is_ipv6 = false;  
                 address = (u32 *) &((struct sockaddr_in *) addr)->sin_addr;  
                 port = ((struct sockaddr_in *) addr)->sin_port;  
668                  break;                  break;
669          default:          default:
670                  goto skip;                  return 0;
         }  
         if (type == SOCK_RAW)  
                 port = htons(sock->sk->sk_protocol);  
         error = ccs_network_entry(is_ipv6, operation, address, port);  
  skip:  
         if (type != SOCK_STREAM)  
                 return error;  
         switch (sock->sk->sk_family) {  
         case PF_INET:  
         case PF_INET6:  
                 if (!ccs_capable(CCS_INET_STREAM_SOCKET_CONNECT))  
                         error = -EPERM;  
                 break;  
671          }          }
672          return error;          if (family == PF_UNIX)
673                    return ccs_check_unix_address(addr, addr_len, &address);
674            return ccs_check_inet_address(addr, addr_len, sock->sk->sk_protocol,
675                                          &address);
676  }  }
677    
678  /* Check permission for setting the local IP address/port pair of a socket. */  /* Check permission for setting the local address of a socket. */
679  static int __ccs_socket_bind_permission(struct socket *sock,  static int __ccs_socket_bind_permission(struct socket *sock,
680                                          struct sockaddr *addr, int addr_len)                                          struct sockaddr *addr, int addr_len)
681  {  {
682          int error = 0;          struct ccs_addr_info address;
683            const u8 family = ccs_sock_family(sock->sk);
684          const unsigned int type = sock->type;          const unsigned int type = sock->type;
685          const u32 *address;          if (!family)
         u16 port;  
         u8 operation;  
         bool is_ipv6;  
         /* Nothing to do if I am a kernel service. */  
         if (segment_eq(get_fs(), KERNEL_DS))  
686                  return 0;                  return 0;
687          switch (type) {          switch (type) {
688          case SOCK_STREAM:          case SOCK_STREAM:
                 operation = CCS_NETWORK_TCP_BIND;  
                 break;  
689          case SOCK_DGRAM:          case SOCK_DGRAM:
                 operation = CCS_NETWORK_UDP_BIND;  
                 break;  
690          case SOCK_RAW:          case SOCK_RAW:
691                  operation = CCS_NETWORK_RAW_BIND;          case SOCK_SEQPACKET:
692                    address.protocol = type;
693                    address.operation = CCS_NETWORK_BIND;
694                  break;                  break;
695          default:          default:
696                  return 0;                  return 0;
697          }          }
698          switch (addr->sa_family) {          if (family == PF_UNIX)
699          case AF_INET6:                  return ccs_check_unix_address(addr, addr_len, &address);
700                  if (addr_len < SIN6_LEN_RFC2133)          return ccs_check_inet_address(addr, addr_len, sock->sk->sk_protocol,
701                          goto skip;                                        &address);
                 is_ipv6 = true;  
                 address = (u32 *) ((struct sockaddr_in6 *) addr)->sin6_addr  
                         .s6_addr;  
                 port = ((struct sockaddr_in6 *) addr)->sin6_port;  
                 break;  
         case AF_INET:  
                 if (addr_len < sizeof(struct sockaddr_in))  
                         goto skip;  
                 is_ipv6 = false;  
                 address = (u32 *) &((struct sockaddr_in *) addr)->sin_addr;  
                 port = ((struct sockaddr_in *) addr)->sin_port;  
                 break;  
         default:  
                 goto skip;  
         }  
         if (type == SOCK_RAW)  
                 port = htons(sock->sk->sk_protocol);  
         error = ccs_network_entry(is_ipv6, operation, address, port);  
  skip:  
         return error;  
702  }  }
703    
704  /* Check permission for accepting a TCP socket. */  /* Check permission for sending a datagram. */
705  static int __ccs_socket_post_accept_permission(struct socket *sock,  static int __ccs_socket_sendmsg_permission(struct socket *sock,
706                                                 struct socket *newsock)                                             struct msghdr *msg, int size)
707  {  {
708          struct sockaddr_storage addr;          struct ccs_addr_info address;
709          struct task_struct * const task = current;          const u8 family = ccs_sock_family(sock->sk);
710          int error = 0;          const unsigned int type = sock->type;
711          int addr_len;          if (!msg->msg_name || !family ||
712          u32 *address;              (type != SOCK_DGRAM && type != SOCK_RAW))
         u16 port;  
         bool is_ipv6;  
         /* Nothing to do if I am a kernel service. */  
         if (segment_eq(get_fs(), KERNEL_DS))  
                 return 0;  
         switch (newsock->sk->sk_family) {  
         case PF_INET:  
         case PF_INET6:  
                 break;  
         default:  
713                  return 0;                  return 0;
714          }          address.protocol = type;
715          error = newsock->ops->getname(newsock, (struct sockaddr *) &addr,          address.operation = CCS_NETWORK_SEND;
716                                        &addr_len, 2);          if (family == PF_UNIX)
717          if (error)                  return ccs_check_unix_address((struct sockaddr *)
718                  return error;                                                msg->msg_name, msg->msg_namelen,
719          switch (((struct sockaddr *) &addr)->sa_family) {                                                &address);
720          case AF_INET6:          return ccs_check_inet_address((struct sockaddr *) msg->msg_name,
721                  is_ipv6 = true;                                        msg->msg_namelen, sock->sk->sk_protocol,
722                  address = (u32 *) ((struct sockaddr_in6 *) &addr)->sin6_addr                                        &address);
                         .s6_addr;  
                 port = ((struct sockaddr_in6 *) &addr)->sin6_port;  
                 break;  
         case AF_INET:  
                 is_ipv6 = false;  
                 address = (u32 *) &((struct sockaddr_in *) &addr)->sin_addr;  
                 port = ((struct sockaddr_in *) &addr)->sin_port;  
                 break;  
         default:  
                 goto skip;  
         }  
         task->ccs_flags |= CCS_DONT_SLEEP_ON_ENFORCE_ERROR;  
         error = ccs_network_entry(is_ipv6, CCS_NETWORK_TCP_ACCEPT, address,  
                                   port);  
         task->ccs_flags &= ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;  
  skip:  
         return error;  
723  }  }
724    
725  /* Check permission for sending a datagram via a UDP or RAW socket. */  /* Check permission for accepting a socket. */
726  static int __ccs_socket_sendmsg_permission(struct socket *sock,  static int __ccs_socket_post_accept_permission(struct socket *sock,
727                                             struct msghdr *msg, int size)                                                 struct socket *newsock)
728  {  {
729          struct sockaddr *addr = (struct sockaddr *) msg->msg_name;          struct ccs_addr_info address;
730          const int addr_len = msg->msg_namelen;          const u8 family = ccs_sock_family(sock->sk);
731          int error = 0;          const unsigned int type = sock->type;
732          const int type = sock->type;          struct sockaddr_storage addr;
733          u32 *address;          int addr_len;
734          u16 port;          if (!family || (type != SOCK_STREAM && type != SOCK_SEQPACKET))
         bool is_ipv6;  
         u8 operation;  
         if (!addr)  
                 return 0;  
         /* Nothing to do if I am a kernel service. */  
         if (segment_eq(get_fs(), KERNEL_DS))  
                 return 0;  
         switch (type) {  
         case SOCK_DGRAM:  
                 operation = CCS_NETWORK_UDP_CONNECT;  
                 break;  
         case SOCK_RAW:  
                 operation = CCS_NETWORK_RAW_CONNECT;  
                 break;  
         default:  
735                  return 0;                  return 0;
736          }          {
737          switch (addr->sa_family) {                  const int error = newsock->ops->getname(newsock,
738          case AF_INET6:                                                          (struct sockaddr *)
739                  if (addr_len < SIN6_LEN_RFC2133)                                                          &addr, &addr_len, 2);
740                          goto skip;                  if (error)
741                  is_ipv6 = true;                          return error;
742                  address = (u32 *) ((struct sockaddr_in6 *) addr)->sin6_addr          }
743                          .s6_addr;          address.protocol = type;
744                  port = ((struct sockaddr_in6 *) addr)->sin6_port;          address.operation = CCS_NETWORK_ACCEPT;
745                  break;          if (family == PF_UNIX)
746          case AF_INET:                  return ccs_check_unix_address((struct sockaddr *) &addr,
747                  if (addr_len < sizeof(struct sockaddr_in))                                                addr_len, &address);
748                          goto skip;          return ccs_check_inet_address((struct sockaddr *) &addr, addr_len, 0,
749                  is_ipv6 = false;                                        &address);
                 address = (u32 *) &((struct sockaddr_in *) addr)->sin_addr;  
                 port = ((struct sockaddr_in *) addr)->sin_port;  
                 break;  
         default:  
                 goto skip;  
         }  
         if (type == SOCK_RAW)  
                 port = htons(sock->sk->sk_protocol);  
         error = ccs_network_entry(is_ipv6, operation, address, port);  
  skip:  
         return error;  
750  }  }
751    
752  #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)  #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
# Line 677  static inline struct ipv6hdr *ipv6_hdr(c Line 772  static inline struct ipv6hdr *ipv6_hdr(c
772  #endif  #endif
773  #endif  #endif
774    
775  /* Check permission for receiving a datagram via a UDP or RAW socket. */  /* Check permission for receiving a datagram. */
776  static int __ccs_socket_post_recvmsg_permission(struct sock *sk,  static int __ccs_socket_post_recvmsg_permission(struct sock *sk,
777                                                  struct sk_buff *skb)                                                  struct sk_buff *skb)
778  {  {
779          struct task_struct * const task = current;          struct ccs_addr_info address;
780          int error = 0;          const u8 family = ccs_sock_family(sk);
781          const unsigned int type = sk->sk_type;          const unsigned int type = sk->sk_type;
782          u16 port;          struct sockaddr_storage addr;
783          bool is_ipv6;          if (!family)
784          u8 operation;                  return 0;
         union {  
                 struct in6_addr sin6;  
                 struct in_addr sin4;  
         } address;  
785          switch (type) {          switch (type) {
786          case SOCK_DGRAM:          case SOCK_DGRAM:
                 operation = CCS_NETWORK_UDP_CONNECT;  
                 break;  
787          case SOCK_RAW:          case SOCK_RAW:
788                  operation = CCS_NETWORK_RAW_CONNECT;                  address.protocol = type;
789                  break;                  break;
790          default:          default:
791                  return 0;                  return 0;
792          }          }
793          /* Nothing to do if I am a kernel service. */          address.operation = CCS_NETWORK_RECV;
794          if (segment_eq(get_fs(), KERNEL_DS))          switch (family) {
                 return 0;  
         switch (sk->sk_family) {  
795          case PF_INET6:          case PF_INET6:
796                  is_ipv6 = true;                  {
797                  if (type == SOCK_DGRAM && skb->protocol == htons(ETH_P_IP))                          struct in6_addr *sin6 = (struct in6_addr *) &addr;
798                          ipv6_addr_set(&address.sin6, 0, 0, htonl(0xffff),                          address.inet.is_ipv6 = true;
799                                        ip_hdr(skb)->saddr);                          if (type == SOCK_DGRAM &&
800                  else                              skb->protocol == htons(ETH_P_IP))
801                          ipv6_addr_copy(&address.sin6, &ipv6_hdr(skb)->saddr);                                  ipv6_addr_set(sin6, 0, 0, htonl(0xffff),
802                  break;                                                ip_hdr(skb)->saddr);
803                            else
804                                    ipv6_addr_copy(sin6, &ipv6_hdr(skb)->saddr);
805                            break;
806                    }
807          case PF_INET:          case PF_INET:
808                  is_ipv6 = false;                  {
809                  address.sin4.s_addr = ip_hdr(skb)->saddr;                          struct in_addr *sin4 = (struct in_addr *) &addr;
810                  break;                          address.inet.is_ipv6 = false;
811          default:                          sin4->s_addr = ip_hdr(skb)->saddr;
812                  goto skip;                          break;
813                    }
814            default: /* == PF_UNIX */
815                    {
816    #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0)
817                            struct unix_address *u = unix_sk(skb->sk)->addr;
818    #else
819                            struct unix_address *u = skb->sk->protinfo.af_unix.addr;
820    #endif
821                            unsigned int addr_len;
822                            if (!u)
823                                    return 0;
824                            addr_len = u->len;
825                            if (addr_len >= sizeof(addr))
826                                    return 0;
827                            memcpy(&addr, u->name, addr_len);
828                            return ccs_check_unix_address((struct sockaddr *) &addr,
829                                                          addr_len, &address);
830                    }
831          }          }
832            address.inet.address = (u32 *) &addr;
833          if (type == SOCK_DGRAM)          if (type == SOCK_DGRAM)
834                  port = udp_hdr(skb)->source;                  address.inet.port = udp_hdr(skb)->source;
835          else          else
836                  port = htons(sk->sk_protocol);                  address.inet.port = htons(sk->sk_protocol);
837          task->ccs_flags |= CCS_DONT_SLEEP_ON_ENFORCE_ERROR;          return ccs_inet_entry(&address);
         error = ccs_network_entry(is_ipv6, operation, (u32 *) &address, port);  
         task->ccs_flags &= ~CCS_DONT_SLEEP_ON_ENFORCE_ERROR;  
  skip:  
         return error;  
838  }  }
839    
840  void __init ccs_network_init(void)  void __init ccs_network_init(void)
841  {  {
842            u8 i;
843            for (i = 0; i < CCS_SOCK_MAX; i++)
844                    if (!ccs_proto_keyword[i])
845                            ccs_proto_keyword[i] = "unknown";
846          ccsecurity_ops.socket_create_permission =          ccsecurity_ops.socket_create_permission =
847                  __ccs_socket_create_permission;                  __ccs_socket_create_permission;
848          ccsecurity_ops.socket_listen_permission =          ccsecurity_ops.socket_listen_permission =
Legend:
Removed from v.3825  
changed lines
  Added in v.3949
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
サイト情報
ソフトウェアを探す
ソフトウェアを作る
コミュニティ
ヘルプ