API tools faq
paste
Guest User

Treviño - kdbus openmoko 2.6.32 kernel support

a guest
Sep 24th, 2010
133
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Diff 190.49 KB | None | 0 0
raw download clone embed print report
  1. diff --git a/include/linux/security.h b/include/linux/security.h
  2. index 0c88191..e1fcd9f 100644
  3. --- a/include/linux/security.h
  4. +++ b/include/linux/security.h
  5. @@ -1563,7 +1563,10 @@ struct security_operations {
  6.  #ifdef CONFIG_SECURITY_NETWORK
  7.         int (*unix_stream_connect) (struct socket *sock,
  8.                                     struct socket *other, struct sock *newsk);
  9. +       int (*dbus_stream_connect) (struct socket *sock,
  10. +                                   struct socket *other, struct sock *newsk);
  11.         int (*unix_may_send) (struct socket *sock, struct socket *other);
  12. +       int (*dbus_may_send) (struct socket *sock, struct socket *other);
  13.  
  14.         int (*socket_create) (int family, int type, int protocol, int kern);
  15.         int (*socket_post_create) (struct socket *sock, int family,
  16. @@ -2518,7 +2521,10 @@ static inline int security_inode_getsecctx(struct inode *inode, void **ctx, u32
  17.  
  18.  int security_unix_stream_connect(struct socket *sock, struct socket *other,
  19.                                  struct sock *newsk);
  20. +int security_dbus_stream_connect(struct socket *sock, struct socket *other,
  21. +                                struct sock *newsk);
  22.  int security_unix_may_send(struct socket *sock,  struct socket *other);
  23. +int security_dbus_may_send(struct socket *sock,  struct socket *other);
  24.  int security_socket_create(int family, int type, int protocol, int kern);
  25.  int security_socket_post_create(struct socket *sock, int family,
  26.                                 int type, int protocol, int kern);
  27. @@ -2562,12 +2568,25 @@ static inline int security_unix_stream_connect(struct socket *sock,
  28.         return 0;
  29.  }
  30.  
  31. +static inline int security_dbus_stream_connect(struct socket *sock,
  32. +                                              struct socket *other,
  33. +                                              struct sock *newsk)
  34. +{
  35. +       return 0;
  36. +}
  37. +
  38.  static inline int security_unix_may_send(struct socket *sock,
  39.                                          struct socket *other)
  40.  {
  41.         return 0;
  42.  }
  43.  
  44. +static inline int security_dbus_may_send(struct socket *sock,
  45. +                                        struct socket *other)
  46. +{
  47. +       return 0;
  48. +}
  49. +
  50.  static inline int security_socket_create(int family, int type,
  51.                                          int protocol, int kern)
  52.  {
  53. diff --git a/include/linux/socket.h b/include/linux/socket.h
  54. index 032a19e..ae8e296 100644
  55. --- a/include/linux/socket.h
  56. +++ b/include/linux/socket.h
  57. @@ -180,7 +180,8 @@
  58.  #define AF_ISDN                34      /* mISDN sockets                */
  59.  #define AF_PHONET      35      /* Phonet sockets               */
  60.  #define AF_IEEE802154  36      /* IEEE802154 sockets           */
  61. -#define AF_MAX         37      /* For now.. */
  62. +#define AF_DBUS                37      /* DBUS sockets                 */
  63. +#define AF_MAX         38      /* For now.. */
  64.  
  65.  /* Protocol families, same as address families. */
  66.  #define PF_UNSPEC      AF_UNSPEC
  67. @@ -220,6 +221,7 @@
  68.  #define PF_ISDN                AF_ISDN
  69.  #define PF_PHONET      AF_PHONET
  70.  #define PF_IEEE802154  AF_IEEE802154
  71. +#define PF_DBUS                AF_DBUS
  72.  #define PF_MAX         AF_MAX
  73.  
  74.  /* Maximum queue length specifiable by listen.  */
  75. diff --git a/include/net/af_dbus.h b/include/net/af_dbus.h
  76. new file mode 100644
  77. index 0000000..0d05784
  78. --- /dev/null
  79. +++ b/include/net/af_dbus.h
  80. @@ -0,0 +1,85 @@
  81. +#ifndef __LINUX_NET_AFDBUS_H
  82. +#define __LINUX_NET_AFDBUS_H
  83. +
  84. +#include <linux/socket.h>
  85. +#include <linux/un.h>
  86. +#include <linux/mutex.h>
  87. +#include <net/sock.h>
  88. +
  89. +extern void dbus_inflight(struct file *fp);
  90. +extern void dbus_notinflight(struct file *fp);
  91. +extern void dbus_gc(void);
  92. +extern void wait_for_dbus_gc(void);
  93. +
  94. +#define DBUS_HASH_SIZE 256
  95. +
  96. +extern unsigned int dbus_tot_inflight;
  97. +
  98. +struct dbus_address {
  99. +       atomic_t        refcnt;
  100. +       int             len;
  101. +       unsigned        hash;
  102. +       struct sockaddr_un name[0];
  103. +};
  104. +
  105. +struct dbus_skb_parms {
  106. +       struct ucred            creds;          /* Skb credentials      */
  107. +       struct scm_fp_list      *fp;            /* Passed files         */
  108. +#ifdef CONFIG_SECURITY_NETWORK
  109. +       u32                     secid;          /* Security ID          */
  110. +#endif
  111. +};
  112. +
  113. +#define DBUSCB(skb)    (*(struct dbus_skb_parms *)&((skb)->cb))
  114. +#define DBUSCREDS(skb) (&DBUSCB((skb)).creds)
  115. +#define DBUSSID(skb)   (&DBUSCB((skb)).secid)
  116. +
  117. +#define dbus_state_lock(s)     spin_lock(&dbus_sk(s)->lock)
  118. +#define dbus_state_unlock(s)   spin_unlock(&dbus_sk(s)->lock)
  119. +#define dbus_state_lock_nested(s) \
  120. +                               spin_lock_nested(&dbus_sk(s)->lock, \
  121. +                               SINGLE_DEPTH_NESTING)
  122. +
  123. +#ifdef __KERNEL__
  124. +/* The AF_DBUS socket */
  125. +struct dbus_sock_priv;
  126. +struct DBusBus;
  127. +struct dbus_sock {
  128. +       /* WARNING: sk has to be the first member */
  129. +       struct sock             sk;
  130. +       struct dbus_address     *addr;
  131. +       struct dentry           *dentry;
  132. +       struct vfsmount         *mnt;
  133. +       struct mutex            readlock;
  134. +       struct sock             *peer;
  135. +       struct sock             *other;
  136. +       struct list_head        link;
  137. +       atomic_long_t           inflight;
  138. +       spinlock_t              lock;
  139. +       unsigned int            gc_candidate : 1;
  140. +       unsigned int            gc_maybe_cycle : 1;
  141. +       struct socket_wq        peer_wq;
  142. +
  143. +       struct dbus_sock_priv   *priv;
  144. +       unsigned int    daemon_side;
  145. +       unsigned int    authenticated;
  146. +       char            *uniq_name;
  147. +#define MAX_WELL_KNOWN_NAMES 10
  148. +       char            *well_known_names[MAX_WELL_KNOWN_NAMES];
  149. +       struct DBusBus  *bus;
  150. +       struct hlist_node       bus_link;
  151. +
  152. +};
  153. +#define dbus_sk(__sk) ((struct dbus_sock *)__sk)
  154. +
  155. +#define peer_wait peer_wq.wait
  156. +
  157. +#ifdef CONFIG_SYSCTL
  158. +extern int dbus_sysctl_register(struct net *net);
  159. +extern void dbus_sysctl_unregister(struct net *net);
  160. +#else
  161. +static inline int dbus_sysctl_register(struct net *net) { return 0; }
  162. +static inline void dbus_sysctl_unregister(struct net *net) {}
  163. +#endif
  164. +#endif
  165. +#endif
  166. diff --git a/net/Kconfig b/net/Kconfig
  167. index 0d68b40..2a7f72d 100644
  168. --- a/net/Kconfig
  169. +++ b/net/Kconfig
  170. @@ -47,6 +47,7 @@ menu "Networking options"
  171.  
  172.  source "net/packet/Kconfig"
  173.  source "net/unix/Kconfig"
  174. +source "net/dbus/Kconfig"
  175.  source "net/xfrm/Kconfig"
  176.  source "net/iucv/Kconfig"
  177.  
  178. diff --git a/net/Makefile b/net/Makefile
  179. index cb7bdc1..bb9fa24 100644
  180. --- a/net/Makefile
  181. +++ b/net/Makefile
  182. @@ -19,6 +19,7 @@ obj-$(CONFIG_NETFILTER)               += netfilter/
  183.  obj-$(CONFIG_INET)             += ipv4/
  184.  obj-$(CONFIG_XFRM)             += xfrm/
  185.  obj-$(CONFIG_UNIX)             += unix/
  186. +obj-$(CONFIG_DBUS)             += dbus/
  187.  ifneq ($(CONFIG_IPV6),)
  188.  obj-y                          += ipv6/
  189.  endif
  190. diff --git a/net/core/sock.c b/net/core/sock.c
  191. index 2cf7f9f..cc96185 100644
  192. --- a/net/core/sock.c
  193. +++ b/net/core/sock.c
  194. @@ -156,7 +156,7 @@ static const char *const af_family_key_strings[AF_MAX+1] = {
  195.    "sk_lock-27"       , "sk_lock-28"          , "sk_lock-AF_CAN"      ,
  196.    "sk_lock-AF_TIPC"  , "sk_lock-AF_BLUETOOTH", "sk_lock-IUCV"        ,
  197.    "sk_lock-AF_RXRPC" , "sk_lock-AF_ISDN"     , "sk_lock-AF_PHONET"   ,
  198. -  "sk_lock-AF_IEEE802154",
  199. +  "sk_lock-AF_IEEE802154", "sk_lock-AF_DBUS",
  200.    "sk_lock-AF_MAX"
  201.  };
  202.  static const char *const af_family_slock_key_strings[AF_MAX+1] = {
  203. @@ -172,7 +172,7 @@ static const char *const af_family_slock_key_strings[AF_MAX+1] = {
  204.    "slock-27"       , "slock-28"          , "slock-AF_CAN"      ,
  205.    "slock-AF_TIPC"  , "slock-AF_BLUETOOTH", "slock-AF_IUCV"     ,
  206.    "slock-AF_RXRPC" , "slock-AF_ISDN"     , "slock-AF_PHONET"   ,
  207. -  "slock-AF_IEEE802154",
  208. +  "slock-AF_IEEE802154", "slock-AF_DBUS",
  209.    "slock-AF_MAX"
  210.  };
  211.  static const char *const af_family_clock_key_strings[AF_MAX+1] = {
  212. @@ -188,7 +188,7 @@ static const char *const af_family_clock_key_strings[AF_MAX+1] = {
  213.    "clock-27"       , "clock-28"          , "clock-AF_CAN"      ,
  214.    "clock-AF_TIPC"  , "clock-AF_BLUETOOTH", "clock-AF_IUCV"     ,
  215.    "clock-AF_RXRPC" , "clock-AF_ISDN"     , "clock-AF_PHONET"   ,
  216. -  "clock-AF_IEEE802154",
  217. +  "clock-AF_IEEE802154", "clock-AF_DBUS",
  218.    "clock-AF_MAX"
  219.  };
  220.  
  221. diff --git a/net/dbus/Kconfig b/net/dbus/Kconfig
  222. new file mode 100644
  223. index 0000000..04a759a
  224. --- /dev/null
  225. +++ b/net/dbus/Kconfig
  226. @@ -0,0 +1,16 @@
  227. +#
  228. +# D-Bus Domain Sockets
  229. +#
  230. +
  231. +config DBUS
  232. +       tristate "DBUS domain sockets (EXPERIMENTAL)"
  233. +       depends on EXPERIMENTAL
  234. +       ---help---
  235. +         If you say Y here, you will include support for D-BUS domain sockets.
  236. +         D-BUS sockets are similar to Unix sockets but with D-Bus routing in
  237. +         order to provide better performances than the traditional
  238. +         dbus-daemon.
  239. +
  240. +         To compile this driver as a module, choose M here: the
  241. +         module will be called dbus.  If unsure, say N.
  242. +
  243. diff --git a/net/dbus/Makefile b/net/dbus/Makefile
  244. new file mode 100644
  245. index 0000000..8df236c
  246. --- /dev/null
  247. +++ b/net/dbus/Makefile
  248. @@ -0,0 +1,8 @@
  249. +#
  250. +# Makefile for the Linux D-Bus domain socket layer.
  251. +#
  252. +
  253. +obj-$(CONFIG_DBUS)     += dbus.o
  254. +
  255. +dbus-y                 := af_dbus.o garbage.o matchrule.o message.o bus.o
  256. +dbus-$(CONFIG_SYSCTL)  += sysctl_net_dbus.o
  257. diff --git a/net/dbus/af_dbus.c b/net/dbus/af_dbus.c
  258. new file mode 100644
  259. index 0000000..3490223
  260. --- /dev/null
  261. +++ b/net/dbus/af_dbus.c
  262. @@ -0,0 +1,2103 @@
  263. +/*
  264. + * DBUS                Implementation of D-Bus domain sockets.
  265. + *
  266. + * Authors:    Alban Crequy <alban.crequy@collabora.co.uk>
  267. + *             Ian Molton <ian.molton@collabora.co.uk>
  268. + *
  269. + * Based on the BSD Unix domain sockets implementation.
  270. + *
  271. + * Authors:    Alan Cox, <alan@lxorguk.ukuu.org.uk>
  272. + *
  273. + *             This program is free software; you can redistribute it and/or
  274. + *             modify it under the terms of the GNU General Public License
  275. + *             as published by the Free Software Foundation; either version
  276. + *             2 of the License, or (at your option) any later version.
  277. + *
  278. + * Fixes:
  279. + *             Linus Torvalds  :       Assorted bug cures.
  280. + *             Niibe Yutaka    :       async I/O support.
  281. + *             Carsten Paeth   :       PF_UNIX check, address fixes.
  282. + *             Alan Cox        :       Limit size of allocated blocks.
  283. + *             Alan Cox        :       Fixed the stupid socketpair bug.
  284. + *             Alan Cox        :       BSD compatibility fine tuning.
  285. + *             Alan Cox        :       Fixed a bug in connect when interrupted.
  286. + *             Alan Cox        :       Sorted out a proper draft version of
  287. + *                                     file descriptor passing hacked up from
  288. + *                                     Mike Shaver's work.
  289. + *             Marty Leisner   :       Fixes to fd passing
  290. + *             Nick Nevin      :       recvmsg bugfix.
  291. + *             Alan Cox        :       Started proper garbage collector
  292. + *             Heiko EiBfeldt  :       Missing verify_area check
  293. + *             Alan Cox        :       Started POSIXisms
  294. + *             Andreas Schwab  :       Replace inode by dentry for proper
  295. + *                                     reference counting
  296. + *             Kirk Petersen   :       Made this a module
  297. + *         Christoph Rohland   :       Elegant non-blocking accept/connect algorithm.
  298. + *                                     Lots of bug fixes.
  299. + *          Alexey Kuznetosv   :       Repaired (I hope) bugs introduces
  300. + *                                     by above two patches.
  301. + *          Andrea Arcangeli   :       If possible we block in connect(2)
  302. + *                                     if the max backlog of the listen socket
  303. + *                                     is been reached. This won't break
  304. + *                                     old apps and it will avoid huge amount
  305. + *                                     of socks hashed (this for unix_gc()
  306. + *                                     performances reasons).
  307. + *                                     Security fix that limits the max
  308. + *                                     number of socks to 2*max_files and
  309. + *                                     the number of skb queueable in the
  310. + *                                     dgram receiver.
  311. + *             Artur Skawina   :       Hash function optimizations
  312. + *          Alexey Kuznetsov   :       Full scale SMP. Lot of bugs are introduced 8)
  313. + *           Malcolm Beattie   :       Set peercred for socketpair
  314. + *          Michal Ostrowski   :       Module initialization cleanup.
  315. + *          Arnaldo C. Melo    :       Remove MOD_{INC,DEC}_USE_COUNT,
  316. + *                                     the core infrastructure is doing that
  317. + *                                     for all net proto families now (2.5.69+)
  318. + *
  319. + *
  320. + * Known differences from reference BSD that was tested:
  321. + *
  322. + *     [TO FIX]
  323. + *     ECONNREFUSED is not returned from one end of a connected() socket to the
  324. + *             other the moment one end closes.
  325. + *     fstat() doesn't return st_dev=0, and give the blksize as high water mark
  326. + *             and a fake inode identifier (nor the BSD first socket fstat twice bug).
  327. + *     [NOT TO FIX]
  328. + *     accept() returns a path name even if the connecting socket has closed
  329. + *             in the meantime (BSD loses the path and gives up).
  330. + *     accept() returns 0 length path for an unbound connector. BSD returns 16
  331. + *             and a null first byte in the path (but not for gethost/peername - BSD bug ??)
  332. + *     socketpair(...SOCK_RAW..) doesn't panic the kernel.
  333. + *     BSD af_unix apparently has connect forgetting to block properly.
  334. + *             (need to check this with the POSIX spec in detail)
  335. + *
  336. + * Differences from 2.0.0-11-... (ANK)
  337. + *     Bug fixes and improvements.
  338. + *             - client shutdown killed server socket.
  339. + *             - removed all useless cli/sti pairs.
  340. + *
  341. + *     Semantic changes/extensions.
  342. + *             - generic control message passing.
  343. + *             - SCM_CREDENTIALS control message.
  344. + *             - "Abstract" (not FS based) socket bindings.
  345. + *               Abstract names are sequences of bytes (not zero terminated)
  346. + *               started by 0, so that this name space does not intersect
  347. + *               with BSD names.
  348. + */
  349. +
  350. +#include <linux/module.h>
  351. +#include <linux/kernel.h>
  352. +#include <linux/signal.h>
  353. +#include <linux/sched.h>
  354. +#include <linux/errno.h>
  355. +#include <linux/string.h>
  356. +#include <linux/stat.h>
  357. +#include <linux/dcache.h>
  358. +#include <linux/namei.h>
  359. +#include <linux/socket.h>
  360. +#include <linux/un.h>
  361. +#include <linux/fcntl.h>
  362. +#include <linux/termios.h>
  363. +#include <linux/sockios.h>
  364. +#include <linux/net.h>
  365. +#include <linux/in.h>
  366. +#include <linux/fs.h>
  367. +#include <linux/slab.h>
  368. +#include <asm/uaccess.h>
  369. +#include <linux/skbuff.h>
  370. +#include <linux/netdevice.h>
  371. +#include <net/net_namespace.h>
  372. +#include <net/sock.h>
  373. +#include <net/tcp_states.h>
  374. +#include <net/af_dbus.h>
  375. +#include <linux/proc_fs.h>
  376. +#include <linux/seq_file.h>
  377. +#include <net/scm.h>
  378. +#include <linux/init.h>
  379. +#include <linux/poll.h>
  380. +#include <linux/rtnetlink.h>
  381. +#include <linux/mount.h>
  382. +#include <net/checksum.h>
  383. +#include <linux/security.h>
  384. +
  385. +#include "dbus-protocol.h"
  386. +#include "matchrule.h"
  387. +#include "message.h"
  388. +#include "bus.h"
  389. +
  390. +static struct hlist_head dbus_socket_table[DBUS_HASH_SIZE + 1];
  391. +static DEFINE_SPINLOCK(dbus_table_lock);
  392. +static atomic_t dbus_nr_socks = ATOMIC_INIT(0);
  393. +
  394. +#define dbus_sockets_unbound   (&dbus_socket_table[DBUS_HASH_SIZE])
  395. +
  396. +#define DBUS_ABSTRACT(sk)      (dbus_sk(sk)->addr->hash != DBUS_HASH_SIZE)
  397. +
  398. +#ifdef CONFIG_SECURITY_NETWORK
  399. +static inline void dbus_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
  400. +{
  401. +       scm->secid = *DBUSSID(skb);
  402. +}
  403. +#else
  404. +static inline void dbus_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
  405. +{ }
  406. +#endif /* CONFIG_SECURITY_NETWORK */
  407. +
  408. +/*
  409. + *  SMP locking strategy:
  410. + *    hash table is protected with spinlock dbus_table_lock
  411. + *    each socket state is protected by separate rwlock.
  412. + */
  413. +
  414. +static inline unsigned dbus_hash_fold(__wsum n)
  415. +{
  416. +       unsigned hash = (__force unsigned)n;
  417. +       hash ^= hash>>16;
  418. +       hash ^= hash>>8;
  419. +       return hash&(DBUS_HASH_SIZE-1);
  420. +}
  421. +
  422. +#define dbus_peer(sk) (dbus_sk(sk)->peer)
  423. +
  424. +static inline int dbus_our_peer(struct sock *sk, struct sock *osk)
  425. +{
  426. +       return dbus_peer(osk) == sk;
  427. +}
  428. +
  429. +static inline int dbus_may_send(struct sock *sk, struct sock *osk)
  430. +{
  431. +       return dbus_peer(osk) == NULL || dbus_our_peer(sk, osk);
  432. +}
  433. +
  434. +static inline int dbus_recvq_full(struct sock const *sk)
  435. +{
  436. +       return skb_queue_len(&sk->sk_receive_queue) > sk->sk_max_ack_backlog;
  437. +}
  438. +
  439. +static struct sock *dbus_peer_get(struct sock *s)
  440. +{
  441. +       struct sock *peer;
  442. +
  443. +       dbus_state_lock(s);
  444. +       peer = dbus_peer(s);
  445. +       if (peer)
  446. +               sock_hold(peer);
  447. +       dbus_state_unlock(s);
  448. +       return peer;
  449. +}
  450. +
  451. +static inline void dbus_release_addr(struct dbus_address *addr)
  452. +{
  453. +       if (atomic_dec_and_test(&addr->refcnt))
  454. +               kfree(addr);
  455. +}
  456. +
  457. +/*
  458. + *     Check dbus socket name:
  459. + *             - should be not zero length.
  460. + *             - if started by not zero, should be NULL terminated (FS object)
  461. + *             - if started by zero, it is abstract name.
  462. + */
  463. +
  464. +static int dbus_mkname(struct sockaddr_un *sunaddr, int len, unsigned *hashp)
  465. +{
  466. +       if (len <= sizeof(short) || len > sizeof(*sunaddr))
  467. +               return -EINVAL;
  468. +       if (!sunaddr || sunaddr->sun_family != AF_DBUS)
  469. +               return -EINVAL;
  470. +       if (sunaddr->sun_path[0]) {
  471. +               /*
  472. +                * This may look like an off by one error but it is a bit more
  473. +                * subtle. 108 is the longest valid AF_DBUS path for a binding.
  474. +                * sun_path[108] doesnt as such exist.  However in kernel space
  475. +                * we are guaranteed that it is a valid memory location in our
  476. +                * kernel address buffer.
  477. +                */
  478. +               ((char *)sunaddr)[len] = 0;
  479. +               len = strlen(sunaddr->sun_path)+1+sizeof(short);
  480. +               return len;
  481. +       }
  482. +
  483. +       *hashp = dbus_hash_fold(csum_partial(sunaddr, len, 0));
  484. +       return len;
  485. +}
  486. +
  487. +static void __dbus_remove_socket(struct sock *sk)
  488. +{
  489. +       sk_del_node_init(sk);
  490. +}
  491. +
  492. +static void __dbus_insert_socket(struct hlist_head *list, struct sock *sk)
  493. +{
  494. +       WARN_ON(!sk_unhashed(sk));
  495. +       sk_add_node(sk, list);
  496. +}
  497. +
  498. +static inline void dbus_remove_socket(struct sock *sk)
  499. +{
  500. +       spin_lock(&dbus_table_lock);
  501. +       __dbus_remove_socket(sk);
  502. +       spin_unlock(&dbus_table_lock);
  503. +}
  504. +
  505. +static inline void dbus_insert_socket(struct hlist_head *list, struct sock *sk)
  506. +{
  507. +       spin_lock(&dbus_table_lock);
  508. +       __dbus_insert_socket(list, sk);
  509. +       spin_unlock(&dbus_table_lock);
  510. +}
  511. +
  512. +static struct sock *__dbus_find_socket_byname(struct net *net,
  513. +                                             struct sockaddr_un *sunname,
  514. +                                             int len, int type, unsigned hash)
  515. +{
  516. +       struct sock *s;
  517. +       struct hlist_node *node;
  518. +
  519. +       sk_for_each(s, node, &dbus_socket_table[hash ^ type]) {
  520. +               struct dbus_sock *u = dbus_sk(s);
  521. +
  522. +               if (!net_eq(sock_net(s), net))
  523. +                       continue;
  524. +
  525. +               if (u->addr->len == len &&
  526. +                   !memcmp(u->addr->name, sunname, len))
  527. +                       goto found;
  528. +       }
  529. +       s = NULL;
  530. +found:
  531. +       return s;
  532. +}
  533. +
  534. +static inline struct sock *dbus_find_socket_byname(struct net *net,
  535. +                                                  struct sockaddr_un *sunname,
  536. +                                                  int len, int type,
  537. +                                                  unsigned hash)
  538. +{
  539. +       struct sock *s;
  540. +
  541. +       spin_lock(&dbus_table_lock);
  542. +       s = __dbus_find_socket_byname(net, sunname, len, type, hash);
  543. +       if (s)
  544. +               sock_hold(s);
  545. +       spin_unlock(&dbus_table_lock);
  546. +       return s;
  547. +}
  548. +
  549. +static struct sock *dbus_find_socket_byinode(struct net *net, struct inode *i)
  550. +{
  551. +       struct sock *s;
  552. +       struct hlist_node *node;
  553. +
  554. +       spin_lock(&dbus_table_lock);
  555. +       sk_for_each(s, node,
  556. +                   &dbus_socket_table[i->i_ino & (DBUS_HASH_SIZE - 1)]) {
  557. +               struct dentry *dentry = dbus_sk(s)->dentry;
  558. +
  559. +               if (!net_eq(sock_net(s), net))
  560. +                       continue;
  561. +
  562. +               if (dentry && dentry->d_inode == i) {
  563. +                       sock_hold(s);
  564. +                       goto found;
  565. +               }
  566. +       }
  567. +       s = NULL;
  568. +found:
  569. +       spin_unlock(&dbus_table_lock);
  570. +       return s;
  571. +}
  572. +
  573. +static inline int dbus_writable(struct sock *sk)
  574. +{
  575. +       return (atomic_read(&sk->sk_wmem_alloc) << 2) <= sk->sk_sndbuf;
  576. +}
  577. +
  578. +static void dbus_write_space(struct sock *sk)
  579. +{
  580. +       struct socket_wq *wq;
  581. +
  582. +       rcu_read_lock();
  583. +       if (dbus_writable(sk)) {
  584. +               wq = rcu_dereference(sk->sk_wq);
  585. +               if (wq_has_sleeper(wq))
  586. +                       wake_up_interruptible_sync(&wq->wait);
  587. +               sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
  588. +       }
  589. +       rcu_read_unlock();
  590. +}
  591. +
  592. +static void dbus_sock_destructor(struct sock *sk)
  593. +{
  594. +       struct dbus_sock *u = dbus_sk(sk);
  595. +
  596. +       skb_queue_purge(&sk->sk_receive_queue);
  597. +
  598. +       WARN_ON(atomic_read(&sk->sk_wmem_alloc));
  599. +       WARN_ON(!sk_unhashed(sk));
  600. +       WARN_ON(sk->sk_socket);
  601. +       if (!sock_flag(sk, SOCK_DEAD)) {
  602. +               printk(KERN_INFO "Attempt to release alive dbus socket: %p\n", sk);
  603. +               return;
  604. +       }
  605. +
  606. +       if (!u->daemon_side &&u->uniq_name &&
  607. +            u->authenticated) {
  608. +               bus_matchmaker_disconnected(u->bus->matchmaker, u);
  609. +               dbus_bus_disconnected(u->bus, u);
  610. +       }
  611. +
  612. +       if (u->addr)
  613. +               dbus_release_addr(u->addr);
  614. +
  615. +       if (u->priv) {
  616. +               kfree(u->priv);
  617. +               u->priv = NULL;
  618. +       }
  619. +
  620. +       if (u->bus) {
  621. +               u->bus = NULL;
  622. +       }
  623. +
  624. +       atomic_dec(&dbus_nr_socks);
  625. +       local_bh_disable();
  626. +       sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
  627. +       local_bh_enable();
  628. +#ifdef DBUS_REFCNT_DEBUG
  629. +       printk(KERN_DEBUG "DBUS %p is destroyed, %d are still alive.\n", sk,
  630. +               atomic_read(&dbus_nr_socks));
  631. +#endif
  632. +}
  633. +
  634. +static int dbus_release_sock(struct sock *sk, int embrion)
  635. +{
  636. +       struct dbus_sock *u = dbus_sk(sk);
  637. +       struct dentry *dentry;
  638. +       struct vfsmount *mnt;
  639. +       struct sock *skpair;
  640. +       struct sk_buff *skb;
  641. +       int state;
  642. +
  643. +       dbus_remove_socket(sk);
  644. +
  645. +       /* Clear state */
  646. +       dbus_state_lock(sk);
  647. +       sock_orphan(sk);
  648. +       sk->sk_shutdown = SHUTDOWN_MASK;
  649. +       dentry       = u->dentry;
  650. +       u->dentry    = NULL;
  651. +       mnt          = u->mnt;
  652. +       u->mnt       = NULL;
  653. +       state = sk->sk_state;
  654. +       sk->sk_state = TCP_CLOSE;
  655. +       dbus_state_unlock(sk);
  656. +
  657. +       wake_up_interruptible_all(&u->peer_wait);
  658. +
  659. +       skpair = dbus_peer(sk);
  660. +
  661. +       if (skpair != NULL) {
  662. +               if (sk->sk_type == SOCK_STREAM) {
  663. +                       dbus_state_lock(skpair);
  664. +                       /* No more writes */
  665. +                       skpair->sk_shutdown = SHUTDOWN_MASK;
  666. +                       if (!skb_queue_empty(&sk->sk_receive_queue) || embrion)
  667. +                               skpair->sk_err = ECONNRESET;
  668. +                       dbus_state_unlock(skpair);
  669. +                       skpair->sk_state_change(skpair);
  670. +                       sk_wake_async(skpair, SOCK_WAKE_WAITD, POLL_HUP);
  671. +               }
  672. +               sock_put(skpair); /* It may now die */
  673. +               dbus_peer(sk) = NULL;
  674. +       }
  675. +
  676. +       /* Try to flush out this socket. Throw out buffers at least */
  677. +
  678. +       while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
  679. +               if (state == TCP_LISTEN)
  680. +                       dbus_release_sock(skb->sk, 1);
  681. +               /* passed fds are erased in the kfree_skb hook        */
  682. +               kfree_skb(skb);
  683. +       }
  684. +
  685. +       if (dentry) {
  686. +               dput(dentry);
  687. +               mntput(mnt);
  688. +       }
  689. +
  690. +       sock_put(sk);
  691. +
  692. +       /* ---- Socket is dead now and most probably destroyed ---- */
  693. +
  694. +       /*
  695. +        * Fixme: BSD difference: In BSD all sockets connected to use get
  696. +        *        ECONNRESET and we die on the spot. In Linux we behave
  697. +        *        like files and pipes do and wait for the last
  698. +        *        dereference.
  699. +        *
  700. +        * Can't we simply set sock->err?
  701. +        *
  702. +        *        What the above comment does talk about? --ANK(980817)
  703. +        */
  704. +
  705. +       if (dbus_tot_inflight)
  706. +               dbus_gc();              /* Garbage collect fds */
  707. +
  708. +       return 0;
  709. +}
  710. +
  711. +static int dbus_listen(struct socket *sock, int backlog)
  712. +{
  713. +       int err;
  714. +       struct sock *sk = sock->sk;
  715. +       struct dbus_sock *u = dbus_sk(sk);
  716. +
  717. +       err = -EOPNOTSUPP;
  718. +       if (sock->type != SOCK_STREAM)
  719. +               goto out;       /* Only stream sockets accept */
  720. +       err = -EINVAL;
  721. +       if (!u->addr)
  722. +               goto out;       /* No listens on an unbound socket */
  723. +
  724. +        u->bus->matchmaker = bus_matchmaker_new();
  725. +
  726. +       dbus_state_lock(sk);
  727. +       if (sk->sk_state != TCP_CLOSE && sk->sk_state != TCP_LISTEN)
  728. +               goto out_unlock;
  729. +       if (backlog > sk->sk_max_ack_backlog)
  730. +               wake_up_interruptible_all(&u->peer_wait);
  731. +       sk->sk_max_ack_backlog  = backlog;
  732. +       sk->sk_state            = TCP_LISTEN;
  733. +       /* set credentials so connect can copy them */
  734. +       sk->sk_peercred.pid     = task_tgid_vnr(current);
  735. +       current_euid_egid(&sk->sk_peercred.uid, &sk->sk_peercred.gid);
  736. +       err = 0;
  737. +
  738. +out_unlock:
  739. +       dbus_state_unlock(sk);
  740. +out:
  741. +       return err;
  742. +}
  743. +
  744. +static int dbus_release(struct socket *);
  745. +static int dbus_bind(struct socket *, struct sockaddr *, int);
  746. +static int dbus_stream_connect(struct socket *, struct sockaddr *,
  747. +                              int addr_len, int flags);
  748. +static int dbus_socketpair(struct socket *, struct socket *);
  749. +static int dbus_accept(struct socket *, struct socket *, int);
  750. +static int dbus_getname(struct socket *, struct sockaddr *, int *, int);
  751. +static unsigned int dbus_poll(struct file *, struct socket *, poll_table *);
  752. +static int dbus_ioctl(struct socket *, unsigned int, unsigned long);
  753. +static int dbus_shutdown(struct socket *, int);
  754. +static int dbus_stream_sendmsg(struct kiocb *, struct socket *,
  755. +                              struct msghdr *, size_t);
  756. +static int dbus_stream_recvmsg(struct kiocb *, struct socket *,
  757. +                              struct msghdr *, size_t, int);
  758. +
  759. +static const struct proto_ops dbus_stream_ops = {
  760. +       .family =       PF_DBUS,
  761. +       .owner =        THIS_MODULE,
  762. +       .release =      dbus_release,
  763. +       .bind =         dbus_bind,
  764. +       .connect =      dbus_stream_connect,
  765. +       .socketpair =   dbus_socketpair,
  766. +       .accept =       dbus_accept,
  767. +       .getname =      dbus_getname,
  768. +       .poll =         dbus_poll,
  769. +       .ioctl =        dbus_ioctl,
  770. +       .listen =       dbus_listen,
  771. +       .shutdown =     dbus_shutdown,
  772. +       .setsockopt =   sock_no_setsockopt,
  773. +       .getsockopt =   sock_no_getsockopt,
  774. +       .sendmsg =      dbus_stream_sendmsg,
  775. +       .recvmsg =      dbus_stream_recvmsg,
  776. +       .mmap =         sock_no_mmap,
  777. +       .sendpage =     sock_no_sendpage,
  778. +};
  779. +
  780. +static struct proto dbus_proto = {
  781. +       .name                   = "DBUS",
  782. +       .owner                  = THIS_MODULE,
  783. +       .obj_size               = sizeof(struct dbus_sock),
  784. +};
  785. +
  786. +struct dbus_sock_priv {
  787. +       int disabled;
  788. +};
  789. +
  790. +/*
  791. + * AF_DBUS sockets do not interact with hardware, hence they
  792. + * dont trigger interrupts - so it's safe for them to have
  793. + * bh-unsafe locking for their sk_receive_queue.lock. Split off
  794. + * this special lock-class by reinitializing the spinlock key:
  795. + */
  796. +static struct lock_class_key af_dbus_sk_receive_queue_lock_key;
  797. +
  798. +static struct sock *dbus_create1(struct net *net, struct socket *sock)
  799. +{
  800. +       struct sock *sk = NULL;
  801. +       struct dbus_sock *u;
  802. +       struct dbus_sock_priv *priv = NULL;
  803. +
  804. +       atomic_inc(&dbus_nr_socks);
  805. +       if (atomic_read(&dbus_nr_socks) > 2 * get_max_files())
  806. +               goto out;
  807. +
  808. +       priv = kzalloc(sizeof(struct dbus_sock_priv), GFP_KERNEL);
  809. +       if (!priv)
  810. +               goto out;
  811. +
  812. +       sk = sk_alloc(net, PF_DBUS, GFP_KERNEL, &dbus_proto);
  813. +       if (!sk) {
  814. +               kfree(priv);
  815. +               goto out;
  816. +       }
  817. +
  818. +       sock_init_data(sock, sk);
  819. +       lockdep_set_class(&sk->sk_receive_queue.lock,
  820. +                               &af_dbus_sk_receive_queue_lock_key);
  821. +
  822. +       sk->sk_write_space      = dbus_write_space;
  823. +       sk->sk_max_ack_backlog  = net->unx.sysctl_max_dgram_qlen;
  824. +       sk->sk_destruct         = dbus_sock_destructor;
  825. +       u         = dbus_sk(sk);
  826. +       u->dentry = NULL;
  827. +       u->mnt    = NULL;
  828. +       spin_lock_init(&u->lock);
  829. +       atomic_long_set(&u->inflight, 0);
  830. +       INIT_LIST_HEAD(&u->link);
  831. +       mutex_init(&u->readlock); /* single task reading lock */
  832. +       init_waitqueue_head(&u->peer_wait);
  833. +       u->priv = priv;
  834. +       u->daemon_side = 0;
  835. +       u->authenticated = 0;
  836. +       u->uniq_name = NULL;
  837. +       u->bus = NULL;
  838. +       INIT_HLIST_NODE(&u->bus_link);
  839. +       dbus_insert_socket(dbus_sockets_unbound, sk);
  840. +out:
  841. +       if (sk == NULL)
  842. +               atomic_dec(&dbus_nr_socks);
  843. +       else {
  844. +               local_bh_disable();
  845. +               sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
  846. +               local_bh_enable();
  847. +       }
  848. +       return sk;
  849. +}
  850. +
  851. +static int dbus_create(struct net *net, struct socket *sock, int protocol,
  852. +                      int kern)
  853. +{
  854. +       if (protocol && protocol != PF_DBUS)
  855. +               return -EPROTONOSUPPORT;
  856. +
  857. +       sock->state = SS_UNCONNECTED;
  858. +
  859. +       switch (sock->type) {
  860. +       case SOCK_STREAM:
  861. +               sock->ops = &dbus_stream_ops;
  862. +               break;
  863. +               /*
  864. +                *      Believe it or not BSD has AF_UNIX, SOCK_RAW though
  865. +                *      nothing uses it.
  866. +                */
  867. +       default:
  868. +               return -ESOCKTNOSUPPORT;
  869. +       }
  870. +
  871. +       return dbus_create1(net, sock) ? 0 : -ENOMEM;
  872. +}
  873. +
  874. +static int dbus_release(struct socket *sock)
  875. +{
  876. +       struct sock *sk = sock->sk;
  877. +
  878. +       if (!sk)
  879. +               return 0;
  880. +
  881. +       sock->sk = NULL;
  882. +
  883. +       return dbus_release_sock(sk, 0);
  884. +}
  885. +
  886. +static int dbus_autobind(struct socket *sock)
  887. +{
  888. +       struct sock *sk = sock->sk;
  889. +       struct net *net = sock_net(sk);
  890. +       struct dbus_sock *u = dbus_sk(sk);
  891. +       static u32 ordernum = 1;
  892. +       struct dbus_address *addr;
  893. +       int err;
  894. +
  895. +       mutex_lock(&u->readlock);
  896. +
  897. +       err = 0;
  898. +       if (u->addr)
  899. +               goto out;
  900. +
  901. +       err = -ENOMEM;
  902. +       addr = kzalloc(sizeof(*addr) + sizeof(short) + 16, GFP_KERNEL);
  903. +       if (!addr)
  904. +               goto out;
  905. +
  906. +       addr->name->sun_family = AF_DBUS;
  907. +       atomic_set(&addr->refcnt, 1);
  908. +
  909. +retry:
  910. +       addr->len = sprintf(addr->name->sun_path+1, "%05x", ordernum) + 1 + sizeof(short);
  911. +       addr->hash = dbus_hash_fold(csum_partial(addr->name, addr->len, 0));
  912. +
  913. +       spin_lock(&dbus_table_lock);
  914. +       ordernum = (ordernum+1)&0xFFFFF;
  915. +
  916. +       if (__dbus_find_socket_byname(net, addr->name, addr->len, sock->type,
  917. +                                     addr->hash)) {
  918. +               spin_unlock(&dbus_table_lock);
  919. +               /* Sanity yield. It is unusual case, but yet... */
  920. +               if (!(ordernum&0xFF))
  921. +                       yield();
  922. +               goto retry;
  923. +       }
  924. +       addr->hash ^= sk->sk_type;
  925. +
  926. +       __dbus_remove_socket(sk);
  927. +       u->addr = addr;
  928. +       __dbus_insert_socket(&dbus_socket_table[addr->hash], sk);
  929. +       spin_unlock(&dbus_table_lock);
  930. +       err = 0;
  931. +
  932. +out:   mutex_unlock(&u->readlock);
  933. +       return err;
  934. +}
  935. +
  936. +static struct sock *dbus_find_other(struct net *net,
  937. +                                   struct sockaddr_un *sunname, int len,
  938. +                                   int type, unsigned hash, int *error)
  939. +{
  940. +       struct sock *u;
  941. +       struct path path;
  942. +       int err = 0;
  943. +
  944. +       if (sunname->sun_path[0]) {
  945. +               struct inode *inode;
  946. +               err = kern_path(sunname->sun_path, LOOKUP_FOLLOW, &path);
  947. +               if (err)
  948. +                       goto fail;
  949. +               inode = path.dentry->d_inode;
  950. +               err = inode_permission(inode, MAY_WRITE);
  951. +               if (err)
  952. +                       goto put_fail;
  953. +
  954. +               err = -ECONNREFUSED;
  955. +               if (!S_ISSOCK(inode->i_mode))
  956. +                       goto put_fail;
  957. +               u = dbus_find_socket_byinode(net, inode);
  958. +               if (!u)
  959. +                       goto put_fail;
  960. +
  961. +               if (u->sk_type == type)
  962. +                       touch_atime(path.mnt, path.dentry);
  963. +
  964. +               path_put(&path);
  965. +
  966. +               err = -EPROTOTYPE;
  967. +               if (u->sk_type != type) {
  968. +                       sock_put(u);
  969. +                       goto fail;
  970. +               }
  971. +       } else {
  972. +               err = -ECONNREFUSED;
  973. +               u = dbus_find_socket_byname(net, sunname, len, type, hash);
  974. +               if (u) {
  975. +                       struct dentry *dentry;
  976. +                       dentry = dbus_sk(u)->dentry;
  977. +                       if (dentry)
  978. +                               touch_atime(dbus_sk(u)->mnt, dentry);
  979. +               } else
  980. +                       goto fail;
  981. +       }
  982. +       return u;
  983. +
  984. +put_fail:
  985. +       path_put(&path);
  986. +fail:
  987. +       *error = err;
  988. +       return NULL;
  989. +}
  990. +
  991. +
  992. +static int dbus_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
  993. +{
  994. +       struct sock *sk = sock->sk;
  995. +       struct net *net = sock_net(sk);
  996. +       struct dbus_sock *u = dbus_sk(sk);
  997. +       struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
  998. +       struct dentry *dentry = NULL;
  999. +       struct nameidata nd;
  1000. +       int err;
  1001. +       unsigned hash;
  1002. +       struct dbus_address *addr;
  1003. +       struct hlist_head *list;
  1004. +
  1005. +       err = -EINVAL;
  1006. +       if (sunaddr->sun_family != AF_DBUS)
  1007. +               goto out;
  1008. +
  1009. +       if (addr_len == sizeof(short)) {
  1010. +               err = dbus_autobind(sock);
  1011. +               goto out;
  1012. +       }
  1013. +
  1014. +       err = dbus_mkname(sunaddr, addr_len, &hash);
  1015. +       if (err < 0)
  1016. +               goto out;
  1017. +       addr_len = err;
  1018. +
  1019. +       mutex_lock(&u->readlock);
  1020. +
  1021. +       err = -EINVAL;
  1022. +       if (u->addr)
  1023. +               goto out_up;
  1024. +
  1025. +       err = -ENOMEM;
  1026. +       addr = kmalloc(sizeof(*addr)+addr_len, GFP_KERNEL);
  1027. +       if (!addr)
  1028. +               goto out_up;
  1029. +
  1030. +       u->bus = dbus_bus_new();
  1031. +       if (!u->bus) {
  1032. +               kfree(addr);
  1033. +               goto out;
  1034. +       }
  1035. +
  1036. +       memcpy(addr->name, sunaddr, addr_len);
  1037. +       addr->len = addr_len;
  1038. +       addr->hash = hash ^ sk->sk_type;
  1039. +       atomic_set(&addr->refcnt, 1);
  1040. +
  1041. +       if (sunaddr->sun_path[0]) {
  1042. +               unsigned int mode;
  1043. +               err = 0;
  1044. +               /*
  1045. +                * Get the parent directory, calculate the hash for last
  1046. +                * component.
  1047. +                */
  1048. +               err = path_lookup(sunaddr->sun_path, LOOKUP_PARENT, &nd);
  1049. +               if (err)
  1050. +                       goto out_mknod_parent;
  1051. +
  1052. +               dentry = lookup_create(&nd, 0);
  1053. +               err = PTR_ERR(dentry);
  1054. +               if (IS_ERR(dentry))
  1055. +                       goto out_mknod_unlock;
  1056. +
  1057. +               /*
  1058. +                * All right, let's create it.
  1059. +                */
  1060. +               mode = S_IFSOCK |
  1061. +                      (SOCK_INODE(sock)->i_mode & ~current_umask());
  1062. +               err = mnt_want_write(nd.path.mnt);
  1063. +               if (err)
  1064. +                       goto out_mknod_dput;
  1065. +               err = security_path_mknod(&nd.path, dentry, mode, 0);
  1066. +               if (err)
  1067. +                       goto out_mknod_drop_write;
  1068. +               err = vfs_mknod(nd.path.dentry->d_inode, dentry, mode, 0);
  1069. +out_mknod_drop_write:
  1070. +               mnt_drop_write(nd.path.mnt);
  1071. +               if (err)
  1072. +                       goto out_mknod_dput;
  1073. +               mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
  1074. +               dput(nd.path.dentry);
  1075. +               nd.path.dentry = dentry;
  1076. +
  1077. +               addr->hash = DBUS_HASH_SIZE;
  1078. +       }
  1079. +
  1080. +       spin_lock(&dbus_table_lock);
  1081. +
  1082. +       if (!sunaddr->sun_path[0]) {
  1083. +               err = -EADDRINUSE;
  1084. +               if (__dbus_find_socket_byname(net, sunaddr, addr_len,
  1085. +                                             sk->sk_type, hash)) {
  1086. +                       dbus_release_addr(addr);
  1087. +                       goto out_unlock;
  1088. +               }
  1089. +
  1090. +               list = &dbus_socket_table[addr->hash];
  1091. +       } else {
  1092. +               list = &dbus_socket_table[dentry->d_inode->i_ino & (DBUS_HASH_SIZE-1)];
  1093. +               u->dentry = nd.path.dentry;
  1094. +               u->mnt    = nd.path.mnt;
  1095. +       }
  1096. +
  1097. +       err = 0;
  1098. +       __dbus_remove_socket(sk);
  1099. +       u->addr = addr;
  1100. +       __dbus_insert_socket(list, sk);
  1101. +
  1102. +out_unlock:
  1103. +       spin_unlock(&dbus_table_lock);
  1104. +out_up:
  1105. +       mutex_unlock(&u->readlock);
  1106. +out:
  1107. +       return err;
  1108. +
  1109. +out_mknod_dput:
  1110. +       dput(dentry);
  1111. +out_mknod_unlock:
  1112. +       mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
  1113. +       path_put(&nd.path);
  1114. +out_mknod_parent:
  1115. +       if (err == -EEXIST)
  1116. +               err = -EADDRINUSE;
  1117. +       dbus_release_addr(addr);
  1118. +       goto out_up;
  1119. +}
  1120. +
  1121. +static long dbus_wait_for_peer(struct sock *other, long timeo)
  1122. +{
  1123. +       struct dbus_sock *u = dbus_sk(other);
  1124. +       int sched;
  1125. +       DEFINE_WAIT(wait);
  1126. +
  1127. +       prepare_to_wait_exclusive(&u->peer_wait, &wait, TASK_INTERRUPTIBLE);
  1128. +
  1129. +       sched = !sock_flag(other, SOCK_DEAD) &&
  1130. +               !(other->sk_shutdown & RCV_SHUTDOWN) &&
  1131. +               dbus_recvq_full(other);
  1132. +
  1133. +       dbus_state_unlock(other);
  1134. +
  1135. +       if (sched)
  1136. +               timeo = schedule_timeout(timeo);
  1137. +
  1138. +       finish_wait(&u->peer_wait, &wait);
  1139. +       return timeo;
  1140. +}
  1141. +
  1142. +static int dbus_stream_connect(struct socket *sock, struct sockaddr *uaddr,
  1143. +                              int addr_len, int flags)
  1144. +{
  1145. +       struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
  1146. +       struct sock *sk = sock->sk;
  1147. +       struct net *net = sock_net(sk);
  1148. +       struct dbus_sock *u = dbus_sk(sk), *newu, *otheru;
  1149. +       struct sock *newsk = NULL;
  1150. +       struct sock *other = NULL;
  1151. +       struct sk_buff *skb = NULL;
  1152. +       unsigned hash;
  1153. +       int st;
  1154. +       int err;
  1155. +       long timeo;
  1156. +
  1157. +       err = dbus_mkname(sunaddr, addr_len, &hash);
  1158. +       if (err < 0)
  1159. +               goto out;
  1160. +       addr_len = err;
  1161. +
  1162. +       if (test_bit(SOCK_PASSCRED, &sock->flags) && !u->addr &&
  1163. +           (err = dbus_autobind(sock)) != 0)
  1164. +               goto out;
  1165. +
  1166. +       timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
  1167. +
  1168. +       /* First of all allocate resources.
  1169. +          If we will make it after state is locked,
  1170. +          we will have to recheck all again in any case.
  1171. +        */
  1172. +
  1173. +       err = -ENOMEM;
  1174. +
  1175. +       /* create new sock for complete connection */
  1176. +       newsk = dbus_create1(sock_net(sk), NULL);
  1177. +       if (newsk == NULL)
  1178. +               goto out;
  1179. +
  1180. +       /* Allocate skb for sending to listening sock */
  1181. +       skb = sock_wmalloc(newsk, 1, 0, GFP_KERNEL);
  1182. +       if (skb == NULL)
  1183. +               goto out;
  1184. +
  1185. +restart:
  1186. +       /*  Find listening sock. */
  1187. +       other = dbus_find_other(net, sunaddr, addr_len, sk->sk_type, hash, &err);
  1188. +       if (!other)
  1189. +               goto out;
  1190. +
  1191. +       /* Latch state of peer */
  1192. +       dbus_state_lock(other);
  1193. +
  1194. +       /* Apparently VFS overslept socket death. Retry. */
  1195. +       if (sock_flag(other, SOCK_DEAD)) {
  1196. +               dbus_state_unlock(other);
  1197. +               sock_put(other);
  1198. +               goto restart;
  1199. +       }
  1200. +
  1201. +       err = -ECONNREFUSED;
  1202. +       if (other->sk_state != TCP_LISTEN)
  1203. +               goto out_unlock;
  1204. +       if (other->sk_shutdown & RCV_SHUTDOWN)
  1205. +               goto out_unlock;
  1206. +
  1207. +       if (dbus_recvq_full(other)) {
  1208. +               err = -EAGAIN;
  1209. +               if (!timeo)
  1210. +                       goto out_unlock;
  1211. +
  1212. +               timeo = dbus_wait_for_peer(other, timeo);
  1213. +
  1214. +               err = sock_intr_errno(timeo);
  1215. +               if (signal_pending(current))
  1216. +                       goto out;
  1217. +               sock_put(other);
  1218. +               goto restart;
  1219. +       }
  1220. +
  1221. +       /* Latch our state.
  1222. +
  1223. +          It is tricky place. We need to grab write lock and cannot
  1224. +          drop lock on peer. It is dangerous because deadlock is
  1225. +          possible. Connect to self case and simultaneous
  1226. +          attempt to connect are eliminated by checking socket
  1227. +          state. other is TCP_LISTEN, if sk is TCP_LISTEN we
  1228. +          check this before attempt to grab lock.
  1229. +
  1230. +          Well, and we have to recheck the state after socket locked.
  1231. +        */
  1232. +       st = sk->sk_state;
  1233. +
  1234. +       switch (st) {
  1235. +       case TCP_CLOSE:
  1236. +               /* This is ok... continue with connect */
  1237. +               break;
  1238. +       case TCP_ESTABLISHED:
  1239. +               /* Socket is already connected */
  1240. +               err = -EISCONN;
  1241. +               goto out_unlock;
  1242. +       default:
  1243. +               err = -EINVAL;
  1244. +               goto out_unlock;
  1245. +       }
  1246. +
  1247. +       dbus_state_lock_nested(sk);
  1248. +
  1249. +       if (sk->sk_state != st) {
  1250. +               dbus_state_unlock(sk);
  1251. +               dbus_state_unlock(other);
  1252. +               sock_put(other);
  1253. +               goto restart;
  1254. +       }
  1255. +
  1256. +       err = security_dbus_stream_connect(sock, other->sk_socket, newsk);
  1257. +       if (err) {
  1258. +               dbus_state_unlock(sk);
  1259. +               goto out_unlock;
  1260. +       }
  1261. +
  1262. +       /* The way is open! Fastly set all the necessary fields... */
  1263. +
  1264. +       sock_hold(sk);
  1265. +       dbus_peer(newsk)        = sk;
  1266. +       newsk->sk_state         = TCP_ESTABLISHED;
  1267. +       newsk->sk_type          = sk->sk_type;
  1268. +       newsk->sk_peercred.pid  = task_tgid_vnr(current);
  1269. +       current_euid_egid(&newsk->sk_peercred.uid, &newsk->sk_peercred.gid);
  1270. +       newu = dbus_sk(newsk);
  1271. +       newu->daemon_side       = 1;
  1272. +       newsk->sk_wq            = &newu->peer_wq;
  1273. +       otheru = dbus_sk(other);
  1274. +       newu->bus = otheru->bus;
  1275. +       u->bus = otheru->bus;
  1276. +
  1277. +       /* copy address information from listening to new sock*/
  1278. +       if (otheru->addr) {
  1279. +               atomic_inc(&otheru->addr->refcnt);
  1280. +               newu->addr = otheru->addr;
  1281. +       }
  1282. +       if (otheru->dentry) {
  1283. +               newu->dentry    = dget(otheru->dentry);
  1284. +               newu->mnt       = mntget(otheru->mnt);
  1285. +       }
  1286. +
  1287. +       /* Set credentials */
  1288. +       sk->sk_peercred = other->sk_peercred;
  1289. +
  1290. +       sock->state     = SS_CONNECTED;
  1291. +       sk->sk_state    = TCP_ESTABLISHED;
  1292. +       sock_hold(newsk);
  1293. +
  1294. +       smp_mb__after_atomic_inc();     /* sock_hold() does an atomic_inc() */
  1295. +       dbus_peer(sk)   = newsk;
  1296. +
  1297. +       dbus_state_unlock(sk);
  1298. +
  1299. +       /* take ten and and send info to listening sock */
  1300. +       spin_lock(&other->sk_receive_queue.lock);
  1301. +       __skb_queue_tail(&other->sk_receive_queue, skb);
  1302. +       spin_unlock(&other->sk_receive_queue.lock);
  1303. +       dbus_state_unlock(other);
  1304. +       other->sk_data_ready(other, 0);
  1305. +       sock_put(other);
  1306. +       return 0;
  1307. +
  1308. +out_unlock:
  1309. +       if (other)
  1310. +               dbus_state_unlock(other);
  1311. +
  1312. +out:
  1313. +       kfree_skb(skb);
  1314. +       if (newsk)
  1315. +               dbus_release_sock(newsk, 0);
  1316. +       if (other)
  1317. +               sock_put(other);
  1318. +       return err;
  1319. +}
  1320. +
  1321. +static int dbus_socketpair(struct socket *socka, struct socket *sockb)
  1322. +{
  1323. +       struct sock *ska = socka->sk, *skb = sockb->sk;
  1324. +
  1325. +       /* Join our sockets back to back */
  1326. +       sock_hold(ska);
  1327. +       sock_hold(skb);
  1328. +       dbus_peer(ska) = skb;
  1329. +       dbus_peer(skb) = ska;
  1330. +       ska->sk_peercred.pid = skb->sk_peercred.pid = task_tgid_vnr(current);
  1331. +       current_euid_egid(&skb->sk_peercred.uid, &skb->sk_peercred.gid);
  1332. +       ska->sk_peercred.uid = skb->sk_peercred.uid;
  1333. +       ska->sk_peercred.gid = skb->sk_peercred.gid;
  1334. +
  1335. +       if (ska->sk_type != SOCK_DGRAM) {
  1336. +               ska->sk_state = TCP_ESTABLISHED;
  1337. +               skb->sk_state = TCP_ESTABLISHED;
  1338. +               socka->state  = SS_CONNECTED;
  1339. +               sockb->state  = SS_CONNECTED;
  1340. +       }
  1341. +       return 0;
  1342. +}
  1343. +
  1344. +static int dbus_accept(struct socket *sock, struct socket *newsock, int flags)
  1345. +{
  1346. +       struct sock *sk = sock->sk;
  1347. +       struct sock *tsk;
  1348. +       struct sk_buff *skb;
  1349. +       int err;
  1350. +
  1351. +       err = -EOPNOTSUPP;
  1352. +       if (sock->type != SOCK_STREAM && sock->type)
  1353. +               goto out;
  1354. +
  1355. +       err = -EINVAL;
  1356. +       if (sk->sk_state != TCP_LISTEN)
  1357. +               goto out;
  1358. +
  1359. +       /* If socket state is TCP_LISTEN it cannot change (for now...),
  1360. +        * so that no locks are necessary.
  1361. +        */
  1362. +
  1363. +       skb = skb_recv_datagram(sk, 0, flags&O_NONBLOCK, &err);
  1364. +       if (!skb) {
  1365. +               /* This means receive shutdown. */
  1366. +               if (err == 0)
  1367. +                       err = -EINVAL;
  1368. +               goto out;
  1369. +       }
  1370. +
  1371. +       tsk = skb->sk;
  1372. +       skb_free_datagram(sk, skb);
  1373. +       wake_up_interruptible(&dbus_sk(sk)->peer_wait);
  1374. +
  1375. +       /* attach accepted sock to socket */
  1376. +       dbus_state_lock(tsk);
  1377. +       newsock->state = SS_CONNECTED;
  1378. +       sock_graft(tsk, newsock);
  1379. +       dbus_state_unlock(tsk);
  1380. +       return 0;
  1381. +
  1382. +out:
  1383. +       return err;
  1384. +}
  1385. +
  1386. +
  1387. +static int dbus_getname(struct socket *sock, struct sockaddr *uaddr, int *uaddr_len, int peer)
  1388. +{
  1389. +       struct sock *sk = sock->sk;
  1390. +       struct dbus_sock *u;
  1391. +       DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, uaddr);
  1392. +       int err = 0;
  1393. +
  1394. +       if (peer) {
  1395. +               sk = dbus_peer_get(sk);
  1396. +
  1397. +               err = -ENOTCONN;
  1398. +               if (!sk)
  1399. +                       goto out;
  1400. +               err = 0;
  1401. +       } else {
  1402. +               sock_hold(sk);
  1403. +       }
  1404. +
  1405. +       u = dbus_sk(sk);
  1406. +       dbus_state_lock(sk);
  1407. +       if (!u->addr) {
  1408. +               sunaddr->sun_family = AF_DBUS;
  1409. +               sunaddr->sun_path[0] = 0;
  1410. +               *uaddr_len = sizeof(short);
  1411. +       } else {
  1412. +               struct dbus_address *addr = u->addr;
  1413. +
  1414. +               *uaddr_len = addr->len;
  1415. +               memcpy(sunaddr, addr->name, *uaddr_len);
  1416. +       }
  1417. +       dbus_state_unlock(sk);
  1418. +       sock_put(sk);
  1419. +out:
  1420. +       return err;
  1421. +}
  1422. +
  1423. +static void dbus_detach_fds(struct scm_cookie *scm, struct sk_buff *skb)
  1424. +{
  1425. +       int i;
  1426. +
  1427. +       scm->fp = DBUSCB(skb).fp;
  1428. +       skb->destructor = sock_wfree;
  1429. +       DBUSCB(skb).fp = NULL;
  1430. +
  1431. +       for (i = scm->fp->count-1; i >= 0; i--)
  1432. +               dbus_notinflight(scm->fp->fp[i]);
  1433. +}
  1434. +
  1435. +static void dbus_destruct_fds(struct sk_buff *skb)
  1436. +{
  1437. +       struct scm_cookie scm;
  1438. +       memset(&scm, 0, sizeof(scm));
  1439. +       dbus_detach_fds(&scm, skb);
  1440. +
  1441. +       /* Alas, it calls VFS */
  1442. +       /* So fscking what? fput() had been SMP-safe since the last Summer */
  1443. +       scm_destroy(&scm);
  1444. +       sock_wfree(skb);
  1445. +}
  1446. +
  1447. +static int dbus_attach_fds(struct scm_cookie *scm, struct sk_buff *skb)
  1448. +{
  1449. +       int i;
  1450. +
  1451. +       /*
  1452. +        * Need to duplicate file references for the sake of garbage
  1453. +        * collection.  Otherwise a socket in the fps might become a
  1454. +        * candidate for GC while the skb is not yet queued.
  1455. +        */
  1456. +       DBUSCB(skb).fp = scm_fp_dup(scm->fp);
  1457. +       if (!DBUSCB(skb).fp)
  1458. +               return -ENOMEM;
  1459. +
  1460. +       for (i = scm->fp->count-1; i >= 0; i--)
  1461. +               dbus_inflight(scm->fp->fp[i]);
  1462. +       skb->destructor = dbus_destruct_fds;
  1463. +       return 0;
  1464. +}
  1465. +
  1466. +/*
  1467. + *     Send AF_DBUS data.
  1468. + */
  1469. +
  1470. +struct delivery_data_t {
  1471. +       struct kiocb *kiocb;
  1472. +       struct msghdr *msg;
  1473. +       struct sk_buff *skb;
  1474. +       size_t len;
  1475. +};
  1476. +
  1477. +static void dbus_stream_deliver(struct sock *other, void *user_data)
  1478. +{
  1479. +       struct delivery_data_t *data = user_data;
  1480. +       struct kiocb *kiocb = data->kiocb;
  1481. +       struct msghdr *msg = data->msg;
  1482. +       size_t len = data->len;
  1483. +
  1484. +       int err;
  1485. +       struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
  1486. +       struct sk_buff *skb_cloned;
  1487. +       bool fds_sent = false;
  1488. +
  1489. +       if (other->sk_state != TCP_ESTABLISHED) {
  1490. +               pr_warning("D-Bus message delivery failure: non established socket!\n");
  1491. +               return;
  1492. +       }
  1493. +
  1494. +       skb_cloned = skb_clone(data->skb, GFP_KERNEL);
  1495. +       if (!skb_cloned) {
  1496. +               pr_warning("D-Bus message delivery failure: skb not cloned!\n");
  1497. +               err = -ENOMEM;
  1498. +               goto out_err;
  1499. +       }
  1500. +
  1501. +       memcpy(DBUSCREDS(skb_cloned), &siocb->scm->creds, sizeof(struct ucred));
  1502. +       /* Only send the fds in the first buffer */
  1503. +       if (siocb->scm->fp && !fds_sent) {
  1504. +               err = dbus_attach_fds(siocb->scm, skb_cloned);
  1505. +               if (err) {
  1506. +                       pr_warning("D-Bus message delivery failure: "
  1507. +                            "fds not attached!\n");
  1508. +                       kfree_skb(skb_cloned);
  1509. +                       goto out_err;
  1510. +               }
  1511. +               fds_sent = true;
  1512. +       }
  1513. +
  1514. +       dbus_state_lock(other);
  1515. +
  1516. +       if (sock_flag(other, SOCK_DEAD) ||
  1517. +           (other->sk_shutdown & RCV_SHUTDOWN))
  1518. +               goto pipe_err_free;
  1519. +
  1520. +       skb_queue_tail(&other->sk_receive_queue, skb_cloned);
  1521. +       dbus_state_unlock(other);
  1522. +       other->sk_data_ready(other, len);
  1523. +
  1524. +       return;
  1525. +
  1526. +pipe_err_free:
  1527. +       dbus_state_unlock(other);
  1528. +       kfree_skb(skb_cloned);
  1529. +
  1530. +       if (!(msg->msg_flags&MSG_NOSIGNAL))
  1531. +               send_sig(SIGPIPE, current, 0);
  1532. +       err = -EPIPE;
  1533. +out_err:
  1534. +       scm_destroy(siocb->scm);
  1535. +       siocb->scm = NULL;
  1536. +       return;
  1537. +}
  1538. +
  1539. +static int dbus_stream_sendmsg(struct kiocb *kiocb, struct socket *sock,
  1540. +                              struct msghdr *msg, size_t len)
  1541. +{
  1542. +       int sent = 0;
  1543. +       struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
  1544. +       struct sock *sk = sock->sk;
  1545. +       struct sock *other = dbus_peer(sk);
  1546. +       struct dbus_sock *otheru = dbus_sk(other);
  1547. +       struct hlist_node *other_node;
  1548. +       struct sockaddr_un *sunaddr = msg->msg_name;
  1549. +       int err;
  1550. +       struct scm_cookie tmp_scm;
  1551. +       struct DBusMessage dbus_message = {0,};
  1552. +       unsigned char *message = NULL;
  1553. +       int parsing_ret;
  1554. +       int main_recipient_found = 0;
  1555. +       struct sk_buff *skb;
  1556. +
  1557. +       pr_debug("D-Bus message received: %zd bytes\n", len);
  1558. +
  1559. +       if (NULL == siocb->scm)
  1560. +               siocb->scm = &tmp_scm;
  1561. +       wait_for_dbus_gc();
  1562. +       err = scm_send(sock, msg, siocb->scm);
  1563. +       if (err < 0)
  1564. +               return err;
  1565. +
  1566. +       err = -EOPNOTSUPP;
  1567. +       if (msg->msg_flags&MSG_OOB)
  1568. +               goto out_err;
  1569. +
  1570. +       if (msg->msg_namelen) {
  1571. +               err = sk->sk_state == TCP_ESTABLISHED ? -EISCONN : -EOPNOTSUPP;
  1572. +               goto out_err;
  1573. +       } else {
  1574. +               sunaddr = NULL;
  1575. +               err = -ENOTCONN;
  1576. +               if (sk->sk_state != TCP_ESTABLISHED)
  1577. +                       goto out_err;
  1578. +       }
  1579. +
  1580. +       if (sk->sk_shutdown & SEND_SHUTDOWN)
  1581. +               goto pipe_err;
  1582. +
  1583. +       if (len > (8192 - 256)) {
  1584. +               pr_warning("Message too big, truncate\n");
  1585. +               len = 8192 - 256;
  1586. +       }
  1587. +
  1588. +       message = kmalloc(len, sk->sk_allocation);
  1589. +       if (!message) {
  1590. +               err = -ENOMEM;
  1591. +               goto out_err;
  1592. +       }
  1593. +       err = memcpy_fromiovecend(message, msg->msg_iov, 0, len);
  1594. +       if (err)
  1595. +               goto out_err;
  1596. +
  1597. +       /* We can parse the message*/
  1598. +       dbus_message.len = len;
  1599. +       dbus_message.new_len = len;
  1600. +       parsing_ret = dbus_message_parse(message, len, &dbus_message);
  1601. +
  1602. +       /* 'NameAcquired' signal for uniq name */
  1603. +       if (dbus_sk(sk)->daemon_side && parsing_ret == 0 &&
  1604. +            dbus_message.type == DBUS_MESSAGE_TYPE_SIGNAL &&
  1605. +            dbus_message.sender && dbus_message.path &&
  1606. +            dbus_message.interface && dbus_message.member &&
  1607. +           dbus_message.arg0 &&
  1608. +            !strcmp(dbus_message.sender, "org.freedesktop.DBus") &&
  1609. +            !strcmp(dbus_message.path, "/org/freedesktop/DBus") &&
  1610. +            !strcmp(dbus_message.interface, "org.freedesktop.DBus") &&
  1611. +            !strcmp(dbus_message.member, "NameAcquired")) {
  1612. +               if (dbus_message.arg0[0] == ':')
  1613. +                       dbus_bus_add_connection(otheru->bus, otheru,
  1614. +                               dbus_message.arg0);
  1615. +               else
  1616. +                       dbus_bus_add_well_known_name(otheru->bus, otheru,
  1617. +                               dbus_message.arg0);
  1618. +       }
  1619. +
  1620. +       /* 'NameLost' signal for well-known name */
  1621. +       if (dbus_sk(sk)->daemon_side && parsing_ret == 0 &&
  1622. +            dbus_message.type == DBUS_MESSAGE_TYPE_SIGNAL &&
  1623. +            dbus_message.sender && dbus_message.path &&
  1624. +            dbus_message.interface && dbus_message.member &&
  1625. +           dbus_message.arg0 && dbus_message.arg0[0] != ':' &&
  1626. +            !strcmp(dbus_message.sender, "org.freedesktop.DBus") &&
  1627. +            !strcmp(dbus_message.path, "/org/freedesktop/DBus") &&
  1628. +            !strcmp(dbus_message.interface, "org.freedesktop.DBus") &&
  1629. +            !strcmp(dbus_message.member, "NameLost")) {
  1630. +               if (dbus_message.arg0[0] == ':')
  1631. +                       dbus_bus_disconnected(otheru->bus, otheru);
  1632. +               else
  1633. +                       dbus_bus_remove_well_known_name(otheru->bus, otheru,
  1634. +                               dbus_message.arg0);
  1635. +       }
  1636. +
  1637. +       /* 'AddMatch' method call */
  1638. +       if (!dbus_sk(sk)->daemon_side && parsing_ret == 0 &&
  1639. +            dbus_message.type == DBUS_MESSAGE_TYPE_METHOD_CALL &&
  1640. +            dbus_message.destination && dbus_message.path &&
  1641. +            dbus_message.interface && dbus_message.member &&
  1642. +            !strcmp(dbus_message.destination, "org.freedesktop.DBus") &&
  1643. +            !strcmp(dbus_message.path, "/org/freedesktop/DBus") &&
  1644. +            !strcmp(dbus_message.interface, "org.freedesktop.DBus") &&
  1645. +            !strcmp(dbus_message.member, "AddMatch")) {
  1646. +               BusMatchRule *rule;
  1647. +               pr_debug("Add match rule \"%s\"\n", dbus_message.arg0);
  1648. +               rule = bus_match_rule_parse(dbus_sk(sk), dbus_message.arg0);
  1649. +               if (rule) {
  1650. +                       bus_matchmaker_add_rule(dbus_sk(sk)->bus->matchmaker, rule);
  1651. +                       pr_debug("Match rule added\n");
  1652. +               } else
  1653. +                       pr_warning("Match rule parsing failed\n");
  1654. +
  1655. +       }
  1656. +
  1657. +       /* Add a sender field */
  1658. +       if (!dbus_sk(sk)->daemon_side && parsing_ret == 0 &&
  1659. +            !dbus_message.sender && dbus_sk(sk)->uniq_name &&
  1660. +            (!dbus_message.destination ||
  1661. +             strcmp(dbus_message.destination, "org.freedesktop.DBus"))) {
  1662. +               dbus_message_add_sender(&dbus_message, dbus_sk(sk)->uniq_name,
  1663. +                    sk->sk_allocation);
  1664. +               message = dbus_message.message;
  1665. +       }
  1666. +
  1667. +       skb = sock_alloc_send_skb(sk, dbus_message.new_len,
  1668. +            msg->msg_flags&MSG_DONTWAIT, &err);
  1669. +
  1670. +       if (skb == NULL)
  1671. +               goto out_err;
  1672. +
  1673. +       if (skb_tailroom(skb) < dbus_message.new_len ||
  1674. +           dbus_message.new_len > ((sk->sk_sndbuf >> 1) - 64) ||
  1675. +           dbus_message.new_len > SKB_MAX_ALLOC) {
  1676. +               /* We don't split messages here */
  1677. +               pr_warning("D-Bus message too big (%zd) "
  1678. +                    "for sk_sndbuf=%d tail_room=%d SKB_MAX_ALLOC=%lu\n",
  1679. +                    dbus_message.new_len, sk->sk_sndbuf, skb_tailroom(skb), SKB_MAX_ALLOC);
  1680. +               kfree_skb(skb);
  1681. +               goto out_err;
  1682. +       }
  1683. +
  1684. +       memcpy(skb_put(skb, dbus_message.new_len), message,
  1685. +            dbus_message.new_len);
  1686. +
  1687. +       /* Delivery to the peer */
  1688. +       if (dbus_sk(sk)->daemon_side || parsing_ret != 0 ||
  1689. +            (dbus_message.destination &&
  1690. +             !strcmp(dbus_message.destination, "org.freedesktop.DBus"))) {
  1691. +               struct delivery_data_t data;
  1692. +               data.kiocb = kiocb;
  1693. +               data.msg = msg;
  1694. +                data.len = dbus_message.new_len;
  1695. +               data.skb = skb;
  1696. +               other = dbus_peer(sk);
  1697. +
  1698. +               if (dbus_sk(sk)->daemon_side)
  1699. +                       pr_debug("Message '%s' "
  1700. +                           "header '%s' -> '%s', "
  1701. +                           "routed [dbus-daemon] -> '%s'\n",
  1702. +                           dbus_message.member ? (char *)dbus_message.member : "(null)",
  1703. +                           dbus_message.sender ? (char *)dbus_message.sender : "(null)",
  1704. +                           dbus_message.destination ? (char *)dbus_message.destination : "(null)",
  1705. +                           (char *)(dbus_sk(other)->uniq_name) ?
  1706. +                           (char *)(dbus_sk(other)->uniq_name) : "(null)");
  1707. +               else
  1708. +                       pr_debug("Message '%s' "
  1709. +                           "header '%s' -> '%s', "
  1710. +                           "routed '%s' -> [dbus-daemon]\n",
  1711. +                           dbus_message.member ? (char *)dbus_message.member : "(null)",
  1712. +                           dbus_message.sender ? (char *)dbus_message.sender : "(null)",
  1713. +                           dbus_message.destination ? (char *)dbus_message.destination : "(null)",
  1714. +                           (char *)(dbus_sk(sk)->uniq_name) ?
  1715. +                           (char *)(dbus_sk(sk)->uniq_name) : "(null)");
  1716. +
  1717. +               dbus_stream_deliver(other, &data);
  1718. +               goto skip_kernel_routing;
  1719. +       }
  1720. +
  1721. +       /* Routed to the unique name or well-known name */
  1722. +       hlist_for_each_entry(otheru, other_node, &dbus_sk(sk)->bus->connections,
  1723. +            bus_link) {
  1724. +               struct delivery_data_t data;
  1725. +               int i, found = 0;
  1726. +               other = &otheru->sk;
  1727. +
  1728. +               if (other->sk_state != TCP_ESTABLISHED) {
  1729. +                       continue;
  1730. +               }
  1731. +               if (other == sk) {
  1732. +                       continue;
  1733. +               }
  1734. +               if (otheru->daemon_side) {
  1735. +                       continue;
  1736. +               }
  1737. +               if (!otheru->authenticated) {
  1738. +                       continue;
  1739. +               }
  1740. +               if (otheru->uniq_name == NULL ||
  1741. +                    dbus_message.destination == NULL) {
  1742. +                       continue;
  1743. +               }
  1744. +               if (!strcmp(otheru->uniq_name,
  1745. +                      dbus_message.destination)) {
  1746. +                       found = 1;
  1747. +               } else for (i = 0 ; i < MAX_WELL_KNOWN_NAMES ; i++) {
  1748. +                       char **name = &otheru->well_known_names[i];
  1749. +                       if (*name && dbus_message.destination &&
  1750. +                            !strcmp(*name, dbus_message.destination)) {
  1751. +                            found = 1;
  1752. +                            break;
  1753. +                       }
  1754. +               }
  1755. +               if (!found)
  1756. +                       continue;
  1757. +
  1758. +               pr_debug("Message '%s' "
  1759. +                    "header '%s' -> '%s', "
  1760. +                    "routed '%s' -> '%s'\n",
  1761. +                   dbus_message.member ? (char *)dbus_message.member : "(null)",
  1762. +                   dbus_message.sender ? (char *)dbus_message.sender : "(null)",
  1763. +                   dbus_message.destination ? (char *)dbus_message.destination : "(null)",
  1764. +                    (char *)(dbus_sk(sk)->uniq_name) ?
  1765. +                    (char *)(dbus_sk(sk)->uniq_name) : "(null)",
  1766. +                    (char *)(otheru->uniq_name) ?
  1767. +                    (char *)(otheru->uniq_name) : "(null)");
  1768. +
  1769. +               main_recipient_found = 1;
  1770. +
  1771. +               data.kiocb = kiocb;
  1772. +               data.msg = msg;
  1773. +               data.len = dbus_message.new_len;
  1774. +               data.skb = skb;
  1775. +               dbus_stream_deliver(other, &data);
  1776. +               break;
  1777. +       }
  1778. +
  1779. +       /* If we didn't find the destination, it is a D-Bus activation. D-Bus
  1780. +         * activation is done in userspace by dbus-daemon. */
  1781. +       if (!main_recipient_found && dbus_message.destination) {
  1782. +               struct delivery_data_t data;
  1783. +               data.kiocb = kiocb;
  1784. +               data.msg = msg;
  1785. +               data.len = dbus_message.new_len;
  1786. +               data.skb = skb;
  1787. +               other = dbus_peer(sk);
  1788. +
  1789. +               pr_debug("Message '%s' "
  1790. +                    "header '%s' -> '%s', "
  1791. +                    "routed '%s' -> [D-Bus activation]\n",
  1792. +                   dbus_message.member ? (char *)dbus_message.member : "(null)",
  1793. +                   dbus_message.sender ? (char *)dbus_message.sender : "(null)",
  1794. +                   dbus_message.destination ? (char *)dbus_message.destination : "(null)",
  1795. +                    (char *)(dbus_sk(sk)->uniq_name) ?
  1796. +                    (char *)(dbus_sk(sk)->uniq_name) : "(null)");
  1797. +
  1798. +               dbus_stream_deliver(other, &data);
  1799. +               goto skip_kernel_routing;
  1800. +       }
  1801. +
  1802. +       /* Generic delivery by match rules */
  1803. +       if (!dbus_sk(sk)->daemon_side && parsing_ret == 0) {
  1804. +               struct delivery_data_t data;
  1805. +               data.kiocb = kiocb;
  1806. +               data.msg = msg;
  1807. +               data.len = dbus_message.new_len;
  1808. +               data.skb = skb;
  1809. +
  1810. +               pr_debug("Message '%s' "
  1811. +                    "header '%s' -> '%s', "
  1812. +                    "routed '%s' -> [match rules]\n",
  1813. +                   dbus_message.member ? (char *)dbus_message.member : "(null)",
  1814. +                   dbus_message.sender ? (char *)dbus_message.sender : "(null)",
  1815. +                   dbus_message.destination ? (char *)dbus_message.destination : "(null)",
  1816. +                    (char *)(dbus_sk(sk)->uniq_name) ?
  1817. +                    (char *)(dbus_sk(sk)->uniq_name) : "(null)");
  1818. +
  1819. +               bus_matchmaker_get_recipients(dbus_sk(sk)->bus->matchmaker,
  1820. +                    dbus_sk(sk), NULL, &dbus_message, dbus_stream_deliver,
  1821. +                    &data);
  1822. +       }
  1823. +
  1824. +skip_kernel_routing:
  1825. +       kfree_skb(skb);
  1826. +       scm_destroy(siocb->scm);
  1827. +       siocb->scm = NULL;
  1828. +       kfree(message);
  1829. +
  1830. +       /* sent may be bigger than len but don't confuse userspace
  1831. +         * applications */
  1832. +       return len;
  1833. +
  1834. +pipe_err:
  1835. +       if (sent == 0 && !(msg->msg_flags&MSG_NOSIGNAL))
  1836. +               send_sig(SIGPIPE, current, 0);
  1837. +       err = -EPIPE;
  1838. +out_err:
  1839. +       scm_destroy(siocb->scm);
  1840. +       siocb->scm = NULL;
  1841. +       if (message) {
  1842. +               kfree(message);
  1843. +       }
  1844. +       return sent ? : err;
  1845. +}
  1846. +
  1847. +static void dbus_copy_addr(struct msghdr *msg, struct sock *sk)
  1848. +{
  1849. +       struct dbus_sock *u = dbus_sk(sk);
  1850. +
  1851. +       msg->msg_namelen = 0;
  1852. +       if (u->addr) {
  1853. +               msg->msg_namelen = u->addr->len;
  1854. +               memcpy(msg->msg_name, u->addr->name, u->addr->len);
  1855. +       }
  1856. +}
  1857. +
  1858. +/*
  1859. + *     Sleep until data has arrive. But check for races..
  1860. + */
  1861. +
  1862. +static long dbus_stream_data_wait(struct sock *sk, long timeo)
  1863. +{
  1864. +       DEFINE_WAIT(wait);
  1865. +
  1866. +       dbus_state_lock(sk);
  1867. +
  1868. +       for (;;) {
  1869. +               prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
  1870. +
  1871. +               if (!skb_queue_empty(&sk->sk_receive_queue) ||
  1872. +                   sk->sk_err ||
  1873. +                   (sk->sk_shutdown & RCV_SHUTDOWN) ||
  1874. +                   signal_pending(current) ||
  1875. +                   !timeo)
  1876. +                       break;
  1877. +
  1878. +               set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
  1879. +               dbus_state_unlock(sk);
  1880. +               timeo = schedule_timeout(timeo);
  1881. +               dbus_state_lock(sk);
  1882. +               clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
  1883. +       }
  1884. +
  1885. +       finish_wait(sk_sleep(sk), &wait);
  1886. +       dbus_state_unlock(sk);
  1887. +       return timeo;
  1888. +}
  1889. +
  1890. +
  1891. +
  1892. +static int dbus_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
  1893. +                              struct msghdr *msg, size_t size,
  1894. +                              int flags)
  1895. +{
  1896. +       struct sock_iocb *siocb = kiocb_to_siocb(iocb);
  1897. +       struct scm_cookie tmp_scm;
  1898. +       struct sock *sk = sock->sk;
  1899. +       struct dbus_sock *u = dbus_sk(sk);
  1900. +       struct sockaddr_un *sunaddr = msg->msg_name;
  1901. +       int copied = 0;
  1902. +       int check_creds = 0;
  1903. +       int target;
  1904. +       int err = 0;
  1905. +       long timeo;
  1906. +
  1907. +       err = -EINVAL;
  1908. +       if (sk->sk_state != TCP_ESTABLISHED)
  1909. +               goto out;
  1910. +
  1911. +       err = -EOPNOTSUPP;
  1912. +       if (flags&MSG_OOB)
  1913. +               goto out;
  1914. +
  1915. +       target = sock_rcvlowat(sk, flags&MSG_WAITALL, size);
  1916. +       timeo = sock_rcvtimeo(sk, flags&MSG_DONTWAIT);
  1917. +
  1918. +       msg->msg_namelen = 0;
  1919. +
  1920. +       /* Lock the socket to prevent queue disordering
  1921. +        * while sleeps in memcpy_tomsg
  1922. +        */
  1923. +
  1924. +       if (!siocb->scm) {
  1925. +               siocb->scm = &tmp_scm;
  1926. +               memset(&tmp_scm, 0, sizeof(tmp_scm));
  1927. +       }
  1928. +
  1929. +       mutex_lock(&u->readlock);
  1930. +
  1931. +       do {
  1932. +               int chunk;
  1933. +               struct sk_buff *skb;
  1934. +
  1935. +               dbus_state_lock(sk);
  1936. +               skb = skb_dequeue(&sk->sk_receive_queue);
  1937. +               if (skb == NULL) {
  1938. +                       if (copied >= target)
  1939. +                               goto unlock;
  1940. +
  1941. +                       /*
  1942. +                        *      POSIX 1003.1g mandates this order.
  1943. +                        */
  1944. +
  1945. +                       err = sock_error(sk);
  1946. +                       if (err)
  1947. +                               goto unlock;
  1948. +                       if (sk->sk_shutdown & RCV_SHUTDOWN)
  1949. +                               goto unlock;
  1950. +
  1951. +                       dbus_state_unlock(sk);
  1952. +                       err = -EAGAIN;
  1953. +                       if (!timeo)
  1954. +                               break;
  1955. +                       mutex_unlock(&u->readlock);
  1956. +
  1957. +                       timeo = dbus_stream_data_wait(sk, timeo);
  1958. +
  1959. +                       if (signal_pending(current)) {
  1960. +                               err = sock_intr_errno(timeo);
  1961. +                               goto out;
  1962. +                       }
  1963. +                       mutex_lock(&u->readlock);
  1964. +                       continue;
  1965. + unlock:
  1966. +                       dbus_state_unlock(sk);
  1967. +                       break;
  1968. +               }
  1969. +               dbus_state_unlock(sk);
  1970. +
  1971. +               if (check_creds) {
  1972. +                       /* Never glue messages from different writers */
  1973. +                       if (memcmp(DBUSCREDS(skb), &siocb->scm->creds,
  1974. +                                  sizeof(siocb->scm->creds)) != 0) {
  1975. +                               skb_queue_head(&sk->sk_receive_queue, skb);
  1976. +                               break;
  1977. +                       }
  1978. +               } else {
  1979. +                       /* Copy credentials */
  1980. +                       siocb->scm->creds = *DBUSCREDS(skb);
  1981. +                       check_creds = 1;
  1982. +               }
  1983. +
  1984. +               /* Copy address just once */
  1985. +               if (sunaddr) {
  1986. +                       dbus_copy_addr(msg, skb->sk);
  1987. +                       sunaddr = NULL;
  1988. +               }
  1989. +
  1990. +               chunk = min_t(unsigned int, skb->len, size);
  1991. +               if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
  1992. +                       skb_queue_head(&sk->sk_receive_queue, skb);
  1993. +                       if (copied == 0)
  1994. +                               copied = -EFAULT;
  1995. +                       break;
  1996. +               }
  1997. +               copied += chunk;
  1998. +               size -= chunk;
  1999. +
  2000. +               /* Mark read part of skb as used */
  2001. +               if (!(flags & MSG_PEEK)) {
  2002. +                       skb_pull(skb, chunk);
  2003. +
  2004. +                       if (DBUSCB(skb).fp)
  2005. +                               dbus_detach_fds(siocb->scm, skb);
  2006. +
  2007. +                       /* put the skb back if we didn't use it up.. */
  2008. +                       if (skb->len) {
  2009. +                               skb_queue_head(&sk->sk_receive_queue, skb);
  2010. +                               break;
  2011. +                       }
  2012. +
  2013. +                       kfree_skb(skb);
  2014. +
  2015. +                       if (siocb->scm->fp)
  2016. +                               break;
  2017. +               } else {
  2018. +                       /* It is questionable, see note in dbus_dgram_recvmsg.
  2019. +                         * FIXMEIM - dgram needed?
  2020. +                        */
  2021. +                       if (DBUSCB(skb).fp)
  2022. +                               siocb->scm->fp = scm_fp_dup(DBUSCB(skb).fp);
  2023. +
  2024. +                       /* put message back and return */
  2025. +                       skb_queue_head(&sk->sk_receive_queue, skb);
  2026. +                       break;
  2027. +               }
  2028. +       } while (size);
  2029. +
  2030. +       mutex_unlock(&u->readlock);
  2031. +       scm_recv(sock, msg, siocb->scm, flags);
  2032. +out:
  2033. +       return copied ? : err;
  2034. +}
  2035. +
  2036. +static int dbus_shutdown(struct socket *sock, int mode)
  2037. +{
  2038. +       struct sock *sk = sock->sk;
  2039. +       struct sock *other;
  2040. +
  2041. +       mode = (mode+1)&(RCV_SHUTDOWN|SEND_SHUTDOWN);
  2042. +
  2043. +       if (mode) {
  2044. +               dbus_state_lock(sk);
  2045. +               sk->sk_shutdown |= mode;
  2046. +               other = dbus_peer(sk);
  2047. +               if (other)
  2048. +                       sock_hold(other);
  2049. +               dbus_state_unlock(sk);
  2050. +               sk->sk_state_change(sk);
  2051. +
  2052. +               if (other && (sk->sk_type == SOCK_STREAM)) {
  2053. +
  2054. +                       int peer_mode = 0;
  2055. +
  2056. +                       if (mode&RCV_SHUTDOWN)
  2057. +                               peer_mode |= SEND_SHUTDOWN;
  2058. +                       if (mode&SEND_SHUTDOWN)
  2059. +                               peer_mode |= RCV_SHUTDOWN;
  2060. +                       dbus_state_lock(other);
  2061. +                       other->sk_shutdown |= peer_mode;
  2062. +                       dbus_state_unlock(other);
  2063. +                       other->sk_state_change(other);
  2064. +                       if (peer_mode == SHUTDOWN_MASK)
  2065. +                               sk_wake_async(other, SOCK_WAKE_WAITD, POLL_HUP);
  2066. +                       else if (peer_mode & RCV_SHUTDOWN)
  2067. +                               sk_wake_async(other, SOCK_WAKE_WAITD, POLL_IN);
  2068. +               }
  2069. +               if (other)
  2070. +                       sock_put(other);
  2071. +       }
  2072. +       return 0;
  2073. +}
  2074. +
  2075. +static int dbus_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
  2076. +{
  2077. +       struct sock *sk = sock->sk;
  2078. +       long amount = 0;
  2079. +       int err;
  2080. +
  2081. +       switch (cmd) {
  2082. +       case SIOCOUTQ: // TIOCOUTQ == 0x5411
  2083. +               amount = sk_wmem_alloc_get(sk);
  2084. +               err = put_user(amount, (int __user *)arg);
  2085. +               break;
  2086. +       case SIOCINQ: // FIONREAD == 0x541B
  2087. +               {
  2088. +                       struct sk_buff *skb;
  2089. +
  2090. +                       if (sk->sk_state == TCP_LISTEN) {
  2091. +                               err = -EINVAL;
  2092. +                               break;
  2093. +                       }
  2094. +
  2095. +                       spin_lock(&sk->sk_receive_queue.lock);
  2096. +                       if (sk->sk_type == SOCK_STREAM) {
  2097. +                               skb_queue_walk(&sk->sk_receive_queue, skb)
  2098. +                                       amount += skb->len;
  2099. +                       }
  2100. +                       spin_unlock(&sk->sk_receive_queue.lock);
  2101. +                       err = put_user(amount, (int __user *)arg);
  2102. +                       break;
  2103. +               }
  2104. +
  2105. +       case 0x5420:
  2106. +               pr_debug("D-Bus ioctl 0x5420 -> returns 42\n");
  2107. +               amount = 42;
  2108. +               err = put_user(amount, (int __user *)arg);
  2109. +               break;
  2110. +       default:
  2111. +               err = -ENOIOCTLCMD;
  2112. +               break;
  2113. +       }
  2114. +       return err;
  2115. +}
  2116. +
  2117. +static unsigned int dbus_poll(struct file *file, struct socket *sock, poll_table *wait)
  2118. +{
  2119. +       struct sock *sk = sock->sk;
  2120. +       unsigned int mask;
  2121. +
  2122. +       sock_poll_wait(file, sk_sleep(sk), wait);
  2123. +       mask = 0;
  2124. +
  2125. +       /* exceptional events? */
  2126. +       if (sk->sk_err)
  2127. +               mask |= POLLERR;
  2128. +       if (sk->sk_shutdown == SHUTDOWN_MASK)
  2129. +               mask |= POLLHUP;
  2130. +       if (sk->sk_shutdown & RCV_SHUTDOWN)
  2131. +               mask |= POLLRDHUP;
  2132. +
  2133. +       /* readable? */
  2134. +       if (!skb_queue_empty(&sk->sk_receive_queue) ||
  2135. +           (sk->sk_shutdown & RCV_SHUTDOWN))
  2136. +               mask |= POLLIN | POLLRDNORM;
  2137. +
  2138. +       /* Connection-based need to check for termination and startup */
  2139. +       if ((sk->sk_type == SOCK_STREAM) &&
  2140. +           sk->sk_state == TCP_CLOSE)
  2141. +               mask |= POLLHUP;
  2142. +
  2143. +       /*
  2144. +        * we set writable also when the other side has shut down the
  2145. +        * connection. This prevents stuck sockets.
  2146. +        */
  2147. +       if (dbus_writable(sk))
  2148. +               mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
  2149. +
  2150. +       return mask;
  2151. +}
  2152. +
  2153. +#ifdef CONFIG_PROC_FS
  2154. +static struct sock *first_dbus_socket(int *i)
  2155. +{
  2156. +       for (*i = 0; *i <= DBUS_HASH_SIZE; (*i)++) {
  2157. +               if (!hlist_empty(&dbus_socket_table[*i]))
  2158. +                       return __sk_head(&dbus_socket_table[*i]);
  2159. +       }
  2160. +       return NULL;
  2161. +}
  2162. +
  2163. +static struct sock *next_dbus_socket(int *i, struct sock *s)
  2164. +{
  2165. +       struct sock *next = sk_next(s);
  2166. +       /* More in this chain? */
  2167. +       if (next)
  2168. +               return next;
  2169. +       /* Look for next non-empty chain. */
  2170. +       for ((*i)++; *i <= DBUS_HASH_SIZE; (*i)++) {
  2171. +               if (!hlist_empty(&dbus_socket_table[*i]))
  2172. +                       return __sk_head(&dbus_socket_table[*i]);
  2173. +       }
  2174. +       return NULL;
  2175. +}
  2176. +
  2177. +struct dbus_iter_state {
  2178. +       struct seq_net_private p;
  2179. +       int i;
  2180. +};
  2181. +
  2182. +static struct sock *dbus_seq_idx(struct seq_file *seq, loff_t pos)
  2183. +{
  2184. +       struct dbus_iter_state *iter = seq->private;
  2185. +       loff_t off = 0;
  2186. +       struct sock *s;
  2187. +
  2188. +       for (s = first_dbus_socket(&iter->i); s; s = next_dbus_socket(&iter->i, s)) {
  2189. +               if (sock_net(s) != seq_file_net(seq))
  2190. +                       continue;
  2191. +               if (off == pos)
  2192. +                       return s;
  2193. +               ++off;
  2194. +       }
  2195. +       return NULL;
  2196. +}
  2197. +
  2198. +static void *dbus_seq_start(struct seq_file *seq, loff_t *pos)
  2199. +       __acquires(dbus_table_lock)
  2200. +{
  2201. +       spin_lock(&dbus_table_lock);
  2202. +       return *pos ? dbus_seq_idx(seq, *pos - 1) : SEQ_START_TOKEN;
  2203. +}
  2204. +
  2205. +static void *dbus_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  2206. +{
  2207. +       struct dbus_iter_state *iter = seq->private;
  2208. +       struct sock *sk = v;
  2209. +       ++*pos;
  2210. +
  2211. +       if (v == SEQ_START_TOKEN)
  2212. +               sk = first_dbus_socket(&iter->i);
  2213. +       else
  2214. +               sk = next_dbus_socket(&iter->i, sk);
  2215. +       while (sk && (sock_net(sk) != seq_file_net(seq)))
  2216. +               sk = next_dbus_socket(&iter->i, sk);
  2217. +       return sk;
  2218. +}
  2219. +
  2220. +static void dbus_seq_stop(struct seq_file *seq, void *v)
  2221. +       __releases(dbus_table_lock)
  2222. +{
  2223. +       spin_unlock(&dbus_table_lock);
  2224. +}
  2225. +
  2226. +static int dbus_seq_show(struct seq_file *seq, void *v)
  2227. +{
  2228. +
  2229. +       if (v == SEQ_START_TOKEN)
  2230. +               seq_puts(seq, "Num       RefCount Protocol Flags    Type St "
  2231. +                        "Inode Path\n");
  2232. +       else {
  2233. +               struct sock *s = v;
  2234. +               struct dbus_sock *u = dbus_sk(s);
  2235. +               dbus_state_lock(s);
  2236. +
  2237. +               seq_printf(seq, "%p: %08X %08X %08X %04X %02X %5lu",
  2238. +                       s,
  2239. +                       atomic_read(&s->sk_refcnt),
  2240. +                       0,
  2241. +                       s->sk_state == TCP_LISTEN ? __SO_ACCEPTCON : 0,
  2242. +                       s->sk_type,
  2243. +                       s->sk_socket ?
  2244. +                       (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTED : SS_UNCONNECTED) :
  2245. +                       (s->sk_state == TCP_ESTABLISHED ? SS_CONNECTING : SS_DISCONNECTING),
  2246. +                       sock_i_ino(s));
  2247. +
  2248. +               if (u->addr) {
  2249. +                       int i, len;
  2250. +                       seq_putc(seq, ' ');
  2251. +
  2252. +                       i = 0;
  2253. +                       len = u->addr->len - sizeof(short);
  2254. +                       if (!DBUS_ABSTRACT(s))
  2255. +                               len--;
  2256. +                       else {
  2257. +                               seq_putc(seq, '@');
  2258. +                               i++;
  2259. +                       }
  2260. +                       for ( ; i < len; i++)
  2261. +                               seq_putc(seq, u->addr->name->sun_path[i]);
  2262. +               }
  2263. +               dbus_state_unlock(s);
  2264. +               seq_putc(seq, '\n');
  2265. +       }
  2266. +
  2267. +       return 0;
  2268. +}
  2269. +
  2270. +static const struct seq_operations dbus_seq_ops = {
  2271. +       .start  = dbus_seq_start,
  2272. +       .next   = dbus_seq_next,
  2273. +       .stop   = dbus_seq_stop,
  2274. +       .show   = dbus_seq_show,
  2275. +};
  2276. +
  2277. +static int dbus_seq_open(struct inode *inode, struct file *file)
  2278. +{
  2279. +       return seq_open_net(inode, file, &dbus_seq_ops,
  2280. +                           sizeof(struct dbus_iter_state));
  2281. +}
  2282. +
  2283. +static const struct file_operations dbus_seq_fops = {
  2284. +       .owner          = THIS_MODULE,
  2285. +       .open           = dbus_seq_open,
  2286. +       .read           = seq_read,
  2287. +       .llseek         = seq_lseek,
  2288. +       .release        = seq_release_net,
  2289. +};
  2290. +
  2291. +#endif
  2292. +
  2293. +static const struct net_proto_family dbus_family_ops = {
  2294. +       .family = PF_DBUS,
  2295. +       .create = dbus_create,
  2296. +       .owner  = THIS_MODULE,
  2297. +};
  2298. +
  2299. +
  2300. +static int dbus_net_init(struct net *net)
  2301. +{
  2302. +       int error = -ENOMEM;
  2303. +
  2304. +       net->unx.sysctl_max_dgram_qlen = 10;
  2305. +       if (dbus_sysctl_register(net))
  2306. +               goto out;
  2307. +
  2308. +#ifdef CONFIG_PROC_FS
  2309. +       if (!proc_net_fops_create(net, "dbus", 0, &dbus_seq_fops)) {
  2310. +               dbus_sysctl_unregister(net);
  2311. +               goto out;
  2312. +       }
  2313. +#endif
  2314. +       error = 0;
  2315. +out:
  2316. +       return error;
  2317. +}
  2318. +
  2319. +static void dbus_net_exit(struct net *net)
  2320. +{
  2321. +       dbus_sysctl_unregister(net);
  2322. +       proc_net_remove(net, "dbus");
  2323. +}
  2324. +
  2325. +static struct pernet_operations dbus_net_ops = {
  2326. +       .init = dbus_net_init,
  2327. +       .exit = dbus_net_exit,
  2328. +};
  2329. +
  2330. +static int __init af_dbus_init(void)
  2331. +{
  2332. +       int rc = -1;
  2333. +       struct sk_buff *dummy_skb;
  2334. +
  2335. +       BUILD_BUG_ON(sizeof(struct dbus_skb_parms) > sizeof(dummy_skb->cb));
  2336. +
  2337. +       rc = proto_register(&dbus_proto, 1);
  2338. +       if (rc != 0) {
  2339. +               printk(KERN_CRIT "%s: Cannot create dbus_sock SLAB cache!\n",
  2340. +                      __func__);
  2341. +               goto out;
  2342. +       }
  2343. +
  2344. +       sock_register(&dbus_family_ops);
  2345. +       register_pernet_subsys(&dbus_net_ops);
  2346. +out:
  2347. +       return rc;
  2348. +}
  2349. +
  2350. +static void __exit af_dbus_exit(void)
  2351. +{
  2352. +       sock_unregister(PF_DBUS);
  2353. +       proto_unregister(&dbus_proto);
  2354. +       unregister_pernet_subsys(&dbus_net_ops);
  2355. +}
  2356. +
  2357. +/* Earlier than device_initcall() so that other drivers invoking
  2358. +   request_module() don't end up in a loop when modprobe tries
  2359. +   to use a DBUS socket. But later than subsys_initcall() because
  2360. +   we depend on stuff initialised there */
  2361. +fs_initcall(af_dbus_init);
  2362. +module_exit(af_dbus_exit);
  2363. +
  2364. +MODULE_LICENSE("GPL");
  2365. +MODULE_ALIAS_NETPROTO(PF_DBUS);
  2366. diff --git a/net/dbus/bus.c b/net/dbus/bus.c
  2367. new file mode 100644
  2368. index 0000000..1da98a6
  2369. --- /dev/null
  2370. +++ b/net/dbus/bus.c
  2371. @@ -0,0 +1,91 @@
  2372. +/* bus.c  The D-Bus bus
  2373. + *
  2374. + * Copyright (C) 2010  Collabora Ltd
  2375. + * Authors:    Alban Crequy <alban.crequy@collabora.co.uk>
  2376. + *
  2377. + * This program is free software; you can redistribute it and/or modify
  2378. + * it under the terms of the GNU General Public License as published by
  2379. + * the Free Software Foundation; either version 2 of the License, or
  2380. + * (at your option) any later version.
  2381. + *
  2382. + * This program is distributed in the hope that it will be useful,
  2383. + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  2384. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  2385. + * GNU General Public License for more details.
  2386. + *
  2387. + * You should have received a copy of the GNU General Public License
  2388. + * along with this program; if not, write to the Free Software
  2389. + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  2390. + *
  2391. + */
  2392. +
  2393. +#include "bus.h"
  2394. +#include "dbus-protocol.h"
  2395. +
  2396. +struct DBusBus *
  2397. +dbus_bus_new (void)
  2398. +{
  2399. +       struct DBusBus *bus = kmalloc(sizeof(struct DBusBus), GFP_KERNEL);
  2400. +       INIT_HLIST_HEAD(&bus->connections);
  2401. +       return bus;
  2402. +}
  2403. +
  2404. +void
  2405. +dbus_bus_free (struct DBusBus *bus)
  2406. +{
  2407. +       kfree(bus);
  2408. +}
  2409. +
  2410. +void
  2411. +dbus_bus_add_connection (struct DBusBus *bus, struct dbus_sock *conn,
  2412. +    const char *unique_name)
  2413. +{
  2414. +       BUG_ON(!unique_name);
  2415. +       BUG_ON(unique_name[0] != ':');
  2416. +
  2417. +       conn->authenticated = 1;
  2418. +       conn->uniq_name =
  2419. +          kmalloc(strlen(unique_name)+1, GFP_KERNEL);
  2420. +       strcpy(conn->uniq_name, unique_name);
  2421. +
  2422. +       hlist_add_head(&conn->bus_link, &bus->connections);
  2423. +}
  2424. +
  2425. +void
  2426. +dbus_bus_disconnected(struct DBusBus *bus, struct dbus_sock *conn)
  2427. +{
  2428. +       if (!bus)
  2429. +               return;
  2430. +
  2431. +       hlist_del_init(&conn->bus_link);
  2432. +}
  2433. +
  2434. +void
  2435. +dbus_bus_add_well_known_name (struct DBusBus *bus,
  2436. +    struct dbus_sock *conn, const char *name)
  2437. +{
  2438. +       int i;
  2439. +       for (i = 0 ; i < MAX_WELL_KNOWN_NAMES ; i++) {
  2440. +               char **nameptr = &conn->well_known_names[i];
  2441. +               if (!*nameptr) {
  2442. +                    *nameptr = kstrdup(name, GFP_KERNEL);
  2443. +                    break;
  2444. +               }
  2445. +       }
  2446. +}
  2447. +
  2448. +void
  2449. +dbus_bus_remove_well_known_name (struct DBusBus *bus,
  2450. +    struct dbus_sock *conn, const char *name)
  2451. +{
  2452. +       int i;
  2453. +       for (i = 0 ; i < MAX_WELL_KNOWN_NAMES ; i++) {
  2454. +               char **nameptr = &conn->well_known_names[i];
  2455. +               if (*nameptr && name &&
  2456. +                   !strcmp(name, *nameptr)) {
  2457. +                    kfree(*nameptr);
  2458. +                    *nameptr = NULL;
  2459. +                    break;
  2460. +               }
  2461. +       }
  2462. +}
  2463. diff --git a/net/dbus/bus.h b/net/dbus/bus.h
  2464. new file mode 100644
  2465. index 0000000..88100f6
  2466. --- /dev/null
  2467. +++ b/net/dbus/bus.h
  2468. @@ -0,0 +1,45 @@
  2469. +/* bus.h  The D-Bus Bus
  2470. + *
  2471. + * Copyright (C) 2010  Collabora Ltd
  2472. + *
  2473. + * This program is free software; you can redistribute it and/or modify
  2474. + * it under the terms of the GNU General Public License as published by
  2475. + * the Free Software Foundation; either version 2 of the License, or
  2476. + * (at your option) any later version.
  2477. + *
  2478. + * This program is distributed in the hope that it will be useful,
  2479. + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  2480. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  2481. + * GNU General Public License for more details.
  2482. + *
  2483. + * You should have received a copy of the GNU General Public License
  2484. + * along with this program; if not, write to the Free Software
  2485. + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  2486. + *
  2487. + */
  2488. +
  2489. +#ifndef DBUS_BUS_H
  2490. +#define DBUS_BUS_H
  2491. +
  2492. +#include <net/af_dbus.h>
  2493. +#include "matchrule.h"
  2494. +
  2495. +struct DBusBus {
  2496. +       struct hlist_head connections;
  2497. +       BusMatchmaker* matchmaker;
  2498. +};
  2499. +
  2500. +
  2501. +struct DBusBus *dbus_bus_new (void);
  2502. +void dbus_bus_free (struct DBusBus *bus);
  2503. +
  2504. +void dbus_bus_add_connection (struct DBusBus *bus, struct dbus_sock  *conn,
  2505. +    const char *unique_name);
  2506. +void dbus_bus_disconnected(struct DBusBus *bus, struct dbus_sock  *conn);
  2507. +
  2508. +void dbus_bus_add_well_known_name (struct DBusBus *bus,
  2509. +    struct dbus_sock *conn, const char *name);
  2510. +void dbus_bus_remove_well_known_name (struct DBusBus *bus,
  2511. +    struct dbus_sock *conn, const char *name);
  2512. +
  2513. +#endif /* DBUS_BUS_H */
  2514. diff --git a/net/dbus/dbus-protocol.h b/net/dbus/dbus-protocol.h
  2515. new file mode 100644
  2516. index 0000000..17798e9
  2517. --- /dev/null
  2518. +++ b/net/dbus/dbus-protocol.h
  2519. @@ -0,0 +1,462 @@
  2520. +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
  2521. +/* dbus-protocol.h  D-Bus protocol constants
  2522. + *
  2523. + * Copyright (C) 2002, 2003  CodeFactory AB
  2524. + * Copyright (C) 2004, 2005 Red Hat, Inc.
  2525. + *
  2526. + * Licensed under the Academic Free License version 2.1
  2527. + *
  2528. + * This program is free software; you can redistribute it and/or modify
  2529. + * it under the terms of the GNU General Public License as published by
  2530. + * the Free Software Foundation; either version 2 of the License, or
  2531. + * (at your option) any later version.
  2532. + *
  2533. + * This program is distributed in the hope that it will be useful,
  2534. + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  2535. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  2536. + * GNU General Public License for more details.
  2537. + *
  2538. + * You should have received a copy of the GNU General Public License
  2539. + * along with this program; if not, write to the Free Software
  2540. + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  2541. + *
  2542. + */
  2543. +
  2544. +#ifndef DBUS_PROTOCOL_H
  2545. +#define DBUS_PROTOCOL_H
  2546. +
  2547. +/* Don't include anything in here from anywhere else. It's
  2548. + * intended for use by any random library.
  2549. + */
  2550. +
  2551. +#ifdef  __cplusplus
  2552. +extern "C" {
  2553. +#if 0
  2554. +} /* avoids confusing emacs indentation */
  2555. +#endif
  2556. +#endif
  2557. +
  2558. +/* Normally docs are in .c files, but there isn't a .c file for this. */
  2559. +/**
  2560. + * @defgroup DBusProtocol Protocol constants
  2561. + * @ingroup  DBus
  2562. + *
  2563. + * @brief Defines constants which are part of the D-Bus protocol
  2564. + *
  2565. + * This header is intended for use by any library, not only libdbus.
  2566. + *
  2567. + * @{
  2568. + */
  2569. +
  2570. +
  2571. +/* Message byte order */
  2572. +#define DBUS_LITTLE_ENDIAN ('l')  /**< Code marking LSB-first byte order in the wire protocol. */
  2573. +#define DBUS_BIG_ENDIAN    ('B')  /**< Code marking MSB-first byte order in the wire protocol. */
  2574. +
  2575. +/** Protocol version. */
  2576. +#define DBUS_MAJOR_PROTOCOL_VERSION 1
  2577. +
  2578. +/** Type code that is never equal to a legitimate type code */
  2579. +#define DBUS_TYPE_INVALID       ((int) '\0')
  2580. +/** #DBUS_TYPE_INVALID as a string literal instead of a int literal */
  2581. +#define DBUS_TYPE_INVALID_AS_STRING        "\0"
  2582. +
  2583. +/* Primitive types */
  2584. +/** Type code marking an 8-bit unsigned integer */
  2585. +#define DBUS_TYPE_BYTE          ((int) 'y')
  2586. +/** #DBUS_TYPE_BYTE as a string literal instead of a int literal */
  2587. +#define DBUS_TYPE_BYTE_AS_STRING           "y"
  2588. +/** Type code marking a boolean */
  2589. +#define DBUS_TYPE_BOOLEAN       ((int) 'b')
  2590. +/** #DBUS_TYPE_BOOLEAN as a string literal instead of a int literal */
  2591. +#define DBUS_TYPE_BOOLEAN_AS_STRING        "b"
  2592. +/** Type code marking a 16-bit signed integer */
  2593. +#define DBUS_TYPE_INT16         ((int) 'n')
  2594. +/** #DBUS_TYPE_INT16 as a string literal instead of a int literal */
  2595. +#define DBUS_TYPE_INT16_AS_STRING          "n"
  2596. +/** Type code marking a 16-bit unsigned integer */
  2597. +#define DBUS_TYPE_UINT16        ((int) 'q')
  2598. +/** #DBUS_TYPE_UINT16 as a string literal instead of a int literal */
  2599. +#define DBUS_TYPE_UINT16_AS_STRING         "q"
  2600. +/** Type code marking a 32-bit signed integer */
  2601. +#define DBUS_TYPE_INT32         ((int) 'i')
  2602. +/** #DBUS_TYPE_INT32 as a string literal instead of a int literal */
  2603. +#define DBUS_TYPE_INT32_AS_STRING          "i"
  2604. +/** Type code marking a 32-bit unsigned integer */
  2605. +#define DBUS_TYPE_UINT32        ((int) 'u')
  2606. +/** #DBUS_TYPE_UINT32 as a string literal instead of a int literal */
  2607. +#define DBUS_TYPE_UINT32_AS_STRING         "u"
  2608. +/** Type code marking a 64-bit signed integer */
  2609. +#define DBUS_TYPE_INT64         ((int) 'x')
  2610. +/** #DBUS_TYPE_INT64 as a string literal instead of a int literal */
  2611. +#define DBUS_TYPE_INT64_AS_STRING          "x"
  2612. +/** Type code marking a 64-bit unsigned integer */
  2613. +#define DBUS_TYPE_UINT64        ((int) 't')
  2614. +/** #DBUS_TYPE_UINT64 as a string literal instead of a int literal */
  2615. +#define DBUS_TYPE_UINT64_AS_STRING         "t"
  2616. +/** Type code marking an 8-byte double in IEEE 754 format */
  2617. +#define DBUS_TYPE_DOUBLE        ((int) 'd')
  2618. +/** #DBUS_TYPE_DOUBLE as a string literal instead of a int literal */
  2619. +#define DBUS_TYPE_DOUBLE_AS_STRING         "d"
  2620. +/** Type code marking a UTF-8 encoded, nul-terminated Unicode string */
  2621. +#define DBUS_TYPE_STRING        ((int) 's')
  2622. +/** #DBUS_TYPE_STRING as a string literal instead of a int literal */
  2623. +#define DBUS_TYPE_STRING_AS_STRING         "s"
  2624. +/** Type code marking a D-Bus object path */
  2625. +#define DBUS_TYPE_OBJECT_PATH   ((int) 'o')
  2626. +/** #DBUS_TYPE_OBJECT_PATH as a string literal instead of a int literal */
  2627. +#define DBUS_TYPE_OBJECT_PATH_AS_STRING    "o"
  2628. +/** Type code marking a D-Bus type signature */
  2629. +#define DBUS_TYPE_SIGNATURE     ((int) 'g')
  2630. +/** #DBUS_TYPE_SIGNATURE as a string literal instead of a int literal */
  2631. +#define DBUS_TYPE_SIGNATURE_AS_STRING      "g"
  2632. +/** Type code marking a unix file descriptor */
  2633. +#define DBUS_TYPE_UNIX_FD      ((int) 'h')
  2634. +/** #DBUS_TYPE_UNIX_FD as a string literal instead of a int literal */
  2635. +#define DBUS_TYPE_UNIX_FD_AS_STRING        "h"
  2636. +
  2637. +/* Compound types */
  2638. +/** Type code marking a D-Bus array type */
  2639. +#define DBUS_TYPE_ARRAY         ((int) 'a')
  2640. +/** #DBUS_TYPE_ARRAY as a string literal instead of a int literal */
  2641. +#define DBUS_TYPE_ARRAY_AS_STRING          "a"
  2642. +/** Type code marking a D-Bus variant type */
  2643. +#define DBUS_TYPE_VARIANT       ((int) 'v')
  2644. +/** #DBUS_TYPE_VARIANT as a string literal instead of a int literal */
  2645. +#define DBUS_TYPE_VARIANT_AS_STRING        "v"
  2646. +
  2647. +/** STRUCT and DICT_ENTRY are sort of special since their codes can't
  2648. + * appear in a type string, instead
  2649. + * DBUS_STRUCT_BEGIN_CHAR/DBUS_DICT_ENTRY_BEGIN_CHAR have to appear
  2650. + */
  2651. +/** Type code used to represent a struct; however, this type code does not appear
  2652. + * in type signatures, instead #DBUS_STRUCT_BEGIN_CHAR and #DBUS_STRUCT_END_CHAR will
  2653. + * appear in a signature.
  2654. + */
  2655. +#define DBUS_TYPE_STRUCT        ((int) 'r')
  2656. +/** #DBUS_TYPE_STRUCT as a string literal instead of a int literal */
  2657. +#define DBUS_TYPE_STRUCT_AS_STRING         "r"
  2658. +/** Type code used to represent a dict entry; however, this type code does not appear
  2659. + * in type signatures, instead #DBUS_DICT_ENTRY_BEGIN_CHAR and #DBUS_DICT_ENTRY_END_CHAR will
  2660. + * appear in a signature.
  2661. + */
  2662. +#define DBUS_TYPE_DICT_ENTRY    ((int) 'e')
  2663. +/** #DBUS_TYPE_DICT_ENTRY as a string literal instead of a int literal */
  2664. +#define DBUS_TYPE_DICT_ENTRY_AS_STRING     "e"
  2665. +
  2666. +/** Does not include #DBUS_TYPE_INVALID, #DBUS_STRUCT_BEGIN_CHAR, #DBUS_STRUCT_END_CHAR,
  2667. + * #DBUS_DICT_ENTRY_BEGIN_CHAR, or #DBUS_DICT_ENTRY_END_CHAR - i.e. it is the number of
  2668. + * valid types, not the number of distinct characters that may appear in a type signature.
  2669. + */
  2670. +#define DBUS_NUMBER_OF_TYPES    (16)
  2671. +
  2672. +/* characters other than typecodes that appear in type signatures */
  2673. +
  2674. +/** Code marking the start of a struct type in a type signature */
  2675. +#define DBUS_STRUCT_BEGIN_CHAR   ((int) '(')
  2676. +/** #DBUS_STRUCT_BEGIN_CHAR as a string literal instead of a int literal */
  2677. +#define DBUS_STRUCT_BEGIN_CHAR_AS_STRING   "("
  2678. +/** Code marking the end of a struct type in a type signature */
  2679. +#define DBUS_STRUCT_END_CHAR     ((int) ')')
  2680. +/** #DBUS_STRUCT_END_CHAR a string literal instead of a int literal */
  2681. +#define DBUS_STRUCT_END_CHAR_AS_STRING     ")"
  2682. +/** Code marking the start of a dict entry type in a type signature */
  2683. +#define DBUS_DICT_ENTRY_BEGIN_CHAR   ((int) '{')
  2684. +/** #DBUS_DICT_ENTRY_BEGIN_CHAR as a string literal instead of a int literal */
  2685. +#define DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING   "{"
  2686. +/** Code marking the end of a dict entry type in a type signature */
  2687. +#define DBUS_DICT_ENTRY_END_CHAR     ((int) '}')
  2688. +/** #DBUS_DICT_ENTRY_END_CHAR as a string literal instead of a int literal */
  2689. +#define DBUS_DICT_ENTRY_END_CHAR_AS_STRING     "}"
  2690. +
  2691. +/** Max length in bytes of a bus name, interface, or member (not object
  2692. + * path, paths are unlimited). This is limited because lots of stuff
  2693. + * is O(n) in this number, plus it would be obnoxious to type in a
  2694. + * paragraph-long method name so most likely something like that would
  2695. + * be an exploit.
  2696. + */
  2697. +#define DBUS_MAXIMUM_NAME_LENGTH 255
  2698. +
  2699. +/** This one is 255 so it fits in a byte */
  2700. +#define DBUS_MAXIMUM_SIGNATURE_LENGTH 255
  2701. +
  2702. +/** Max length of a match rule string; to keep people from hosing the
  2703. + * daemon with some huge rule
  2704. + */
  2705. +#define DBUS_MAXIMUM_MATCH_RULE_LENGTH 1024
  2706. +
  2707. +/** Max arg number you can match on in a match rule, e.g.
  2708. + * arg0='hello' is OK, arg3489720987='hello' is not
  2709. + */
  2710. +#define DBUS_MAXIMUM_MATCH_RULE_ARG_NUMBER 63
  2711. +  
  2712. +/** Max length of a marshaled array in bytes (64M, 2^26) We use signed
  2713. + * int for lengths so must be INT_MAX or less.  We need something a
  2714. + * bit smaller than INT_MAX because the array is inside a message with
  2715. + * header info, etc.  so an INT_MAX array wouldn't allow the message
  2716. + * overhead.  The 64M number is an attempt at a larger number than
  2717. + * we'd reasonably ever use, but small enough that your bus would chew
  2718. + * through it fairly quickly without locking up forever. If you have
  2719. + * data that's likely to be larger than this, you should probably be
  2720. + * sending it in multiple incremental messages anyhow.
  2721. + */
  2722. +#define DBUS_MAXIMUM_ARRAY_LENGTH (67108864)
  2723. +/** Number of bits you need in an unsigned to store the max array size */
  2724. +#define DBUS_MAXIMUM_ARRAY_LENGTH_BITS 26
  2725. +
  2726. +/** The maximum total message size including header and body; similar
  2727. + * rationale to max array size.
  2728. + */
  2729. +#define DBUS_MAXIMUM_MESSAGE_LENGTH (DBUS_MAXIMUM_ARRAY_LENGTH * 2)
  2730. +/** Number of bits you need in an unsigned to store the max message size */
  2731. +#define DBUS_MAXIMUM_MESSAGE_LENGTH_BITS 27
  2732. +
  2733. +/** The maximum total number of unix fds in a message. Similar
  2734. + * rationale as DBUS_MAXIMUM_MESSAGE_LENGTH. However we divide by four
  2735. + * given that one fd is an int and hence at least 32 bits.
  2736. + */
  2737. +#define DBUS_MAXIMUM_MESSAGE_UNIX_FDS (DBUS_MAXIMUM_MESSAGE_LENGTH/4)
  2738. +/** Number of bits you need in an unsigned to store the max message unix fds */
  2739. +#define DBUS_MAXIMUM_MESSAGE_UNIX_FDS_BITS (DBUS_MAXIMUM_MESSAGE_LENGTH_BITS-2)
  2740. +
  2741. +/** Depth of recursion in the type tree. This is automatically limited
  2742. + * to DBUS_MAXIMUM_SIGNATURE_LENGTH since you could only have an array
  2743. + * of array of array of ... that fit in the max signature.  But that's
  2744. + * probably a bit too large.
  2745. + */
  2746. +#define DBUS_MAXIMUM_TYPE_RECURSION_DEPTH 32
  2747. +
  2748. +/* Types of message */
  2749. +
  2750. +/** This value is never a valid message type, see dbus_message_get_type() */
  2751. +#define DBUS_MESSAGE_TYPE_INVALID       0
  2752. +/** Message type of a method call message, see dbus_message_get_type() */
  2753. +#define DBUS_MESSAGE_TYPE_METHOD_CALL   1
  2754. +/** Message type of a method return message, see dbus_message_get_type() */
  2755. +#define DBUS_MESSAGE_TYPE_METHOD_RETURN 2
  2756. +/** Message type of an error reply message, see dbus_message_get_type() */
  2757. +#define DBUS_MESSAGE_TYPE_ERROR         3
  2758. +/** Message type of a signal message, see dbus_message_get_type() */
  2759. +#define DBUS_MESSAGE_TYPE_SIGNAL        4
  2760. +
  2761. +#define DBUS_NUM_MESSAGE_TYPES          5
  2762. +
  2763. +/* Header flags */
  2764. +
  2765. +/** If set, this flag means that the sender of a message does not care about getting
  2766. + * a reply, so the recipient need not send one. See dbus_message_set_no_reply().
  2767. + */
  2768. +#define DBUS_HEADER_FLAG_NO_REPLY_EXPECTED 0x1
  2769. +/**
  2770. + * If set, this flag means that even if the message bus knows how to start an owner for
  2771. + * the destination bus name (see dbus_message_set_destination()), it should not
  2772. + * do so. If this flag is not set, the bus may launch a program to process the
  2773. + * message.
  2774. + */
  2775. +#define DBUS_HEADER_FLAG_NO_AUTO_START     0x2
  2776. +
  2777. +/* Header fields */
  2778. +
  2779. +/** Not equal to any valid header field code */
  2780. +#define DBUS_HEADER_FIELD_INVALID        0
  2781. +/** Header field code for the path - the path is the object emitting a signal or the object receiving a method call.
  2782. + * See dbus_message_set_path().
  2783. + */
  2784. +#define DBUS_HEADER_FIELD_PATH           1
  2785. +/** Header field code for the interface containing a member (method or signal).
  2786. + * See dbus_message_set_interface().
  2787. + */
  2788. +#define DBUS_HEADER_FIELD_INTERFACE      2
  2789. +/** Header field code for a member (method or signal). See dbus_message_set_member(). */
  2790. +#define DBUS_HEADER_FIELD_MEMBER         3
  2791. +/** Header field code for an error name (found in #DBUS_MESSAGE_TYPE_ERROR messages).
  2792. + * See dbus_message_set_error_name().
  2793. + */
  2794. +#define DBUS_HEADER_FIELD_ERROR_NAME     4
  2795. +/** Header field code for a reply serial, used to match a #DBUS_MESSAGE_TYPE_METHOD_RETURN message with the
  2796. + * message that it's a reply to. See dbus_message_set_reply_serial().
  2797. + */
  2798. +#define DBUS_HEADER_FIELD_REPLY_SERIAL   5
  2799. +/**
  2800. + * Header field code for the destination bus name of a message. See dbus_message_set_destination().
  2801. + */
  2802. +#define DBUS_HEADER_FIELD_DESTINATION    6
  2803. +/**
  2804. + * Header field code for the sender of a message; usually initialized by the message bus.
  2805. + * See dbus_message_set_sender().
  2806. + */
  2807. +#define DBUS_HEADER_FIELD_SENDER         7
  2808. +/**
  2809. + * Header field code for the type signature of a message.
  2810. + */
  2811. +#define DBUS_HEADER_FIELD_SIGNATURE      8
  2812. +/**
  2813. + * Header field code for the number of unix file descriptors associated
  2814. + * with this message.
  2815. + */
  2816. +#define DBUS_HEADER_FIELD_UNIX_FDS       9
  2817. +
  2818. +
  2819. +/**
  2820. + * Value of the highest-numbered header field code, can be used to determine
  2821. + * the size of an array indexed by header field code. Remember though
  2822. + * that unknown codes must be ignored, so check for that before
  2823. + * indexing the array.
  2824. + */
  2825. +#define DBUS_HEADER_FIELD_LAST DBUS_HEADER_FIELD_UNIX_FDS
  2826. +
  2827. +/** Header format is defined as a signature:
  2828. + *   byte                            byte order
  2829. + *   byte                            message type ID
  2830. + *   byte                            flags
  2831. + *   byte                            protocol version
  2832. + *   uint32                          body length
  2833. + *   uint32                          serial
  2834. + *   array of struct (byte,variant)  (field name, value)
  2835. + *
  2836. + * The length of the header can be computed as the
  2837. + * fixed size of the initial data, plus the length of
  2838. + * the array at the end, plus padding to an 8-boundary.
  2839. + */
  2840. +#define DBUS_HEADER_SIGNATURE                   \
  2841. +     DBUS_TYPE_BYTE_AS_STRING                   \
  2842. +     DBUS_TYPE_BYTE_AS_STRING                   \
  2843. +     DBUS_TYPE_BYTE_AS_STRING                   \
  2844. +     DBUS_TYPE_BYTE_AS_STRING                   \
  2845. +     DBUS_TYPE_UINT32_AS_STRING                 \
  2846. +     DBUS_TYPE_UINT32_AS_STRING                 \
  2847. +     DBUS_TYPE_ARRAY_AS_STRING                  \
  2848. +     DBUS_STRUCT_BEGIN_CHAR_AS_STRING           \
  2849. +     DBUS_TYPE_BYTE_AS_STRING                   \
  2850. +     DBUS_TYPE_VARIANT_AS_STRING                \
  2851. +     DBUS_STRUCT_END_CHAR_AS_STRING
  2852. +
  2853. +
  2854. +/**
  2855. + * The smallest header size that can occur.  (It won't be valid due to
  2856. + * missing required header fields.) This is 4 bytes, two uint32, an
  2857. + * array length. This isn't any kind of resource limit, just the
  2858. + * necessary/logical outcome of the header signature.
  2859. + */
  2860. +#define DBUS_MINIMUM_HEADER_SIZE 16
  2861. +
  2862. +/* Errors */
  2863. +/* WARNING these get autoconverted to an enum in dbus-glib.h. Thus,
  2864. + * if you change the order it breaks the ABI. Keep them in order.
  2865. + * Also, don't change the formatting since that will break the sed
  2866. + * script.
  2867. + */
  2868. +/** A generic error; "something went wrong" - see the error message for more. */
  2869. +#define DBUS_ERROR_FAILED                     "org.freedesktop.DBus.Error.Failed"
  2870. +/** There was not enough memory to complete an operation. */
  2871. +#define DBUS_ERROR_NO_MEMORY                  "org.freedesktop.DBus.Error.NoMemory"
  2872. +/** The bus doesn't know how to launch a service to supply the bus name you wanted. */
  2873. +#define DBUS_ERROR_SERVICE_UNKNOWN            "org.freedesktop.DBus.Error.ServiceUnknown"
  2874. +/** The bus name you referenced doesn't exist (i.e. no application owns it). */
  2875. +#define DBUS_ERROR_NAME_HAS_NO_OWNER          "org.freedesktop.DBus.Error.NameHasNoOwner"
  2876. +/** No reply to a message expecting one, usually means a timeout occurred. */
  2877. +#define DBUS_ERROR_NO_REPLY                   "org.freedesktop.DBus.Error.NoReply"
  2878. +/** Something went wrong reading or writing to a socket, for example. */
  2879. +#define DBUS_ERROR_IO_ERROR                   "org.freedesktop.DBus.Error.IOError"
  2880. +/** A D-Bus bus address was malformed. */
  2881. +#define DBUS_ERROR_BAD_ADDRESS                "org.freedesktop.DBus.Error.BadAddress"
  2882. +/** Requested operation isn't supported (like ENOSYS on UNIX). */
  2883. +#define DBUS_ERROR_NOT_SUPPORTED              "org.freedesktop.DBus.Error.NotSupported"
  2884. +/** Some limited resource is exhausted. */
  2885. +#define DBUS_ERROR_LIMITS_EXCEEDED            "org.freedesktop.DBus.Error.LimitsExceeded"
  2886. +/** Security restrictions don't allow doing what you're trying to do. */
  2887. +#define DBUS_ERROR_ACCESS_DENIED              "org.freedesktop.DBus.Error.AccessDenied"
  2888. +/** Authentication didn't work. */
  2889. +#define DBUS_ERROR_AUTH_FAILED                "org.freedesktop.DBus.Error.AuthFailed"
  2890. +/** Unable to connect to server (probably caused by ECONNREFUSED on a socket). */
  2891. +#define DBUS_ERROR_NO_SERVER                  "org.freedesktop.DBus.Error.NoServer"
  2892. +/** Certain timeout errors, possibly ETIMEDOUT on a socket.
  2893. + * Note that #DBUS_ERROR_NO_REPLY is used for message reply timeouts.
  2894. + * @warning this is confusingly-named given that #DBUS_ERROR_TIMED_OUT also exists. We can't fix
  2895. + * it for compatibility reasons so just be careful.
  2896. + */
  2897. +#define DBUS_ERROR_TIMEOUT                    "org.freedesktop.DBus.Error.Timeout"
  2898. +/** No network access (probably ENETUNREACH on a socket). */
  2899. +#define DBUS_ERROR_NO_NETWORK                 "org.freedesktop.DBus.Error.NoNetwork"
  2900. +/** Can't bind a socket since its address is in use (i.e. EADDRINUSE). */
  2901. +#define DBUS_ERROR_ADDRESS_IN_USE             "org.freedesktop.DBus.Error.AddressInUse"
  2902. +/** The connection is disconnected and you're trying to use it. */
  2903. +#define DBUS_ERROR_DISCONNECTED               "org.freedesktop.DBus.Error.Disconnected"
  2904. +/** Invalid arguments passed to a method call. */
  2905. +#define DBUS_ERROR_INVALID_ARGS               "org.freedesktop.DBus.Error.InvalidArgs"
  2906. +/** Missing file. */
  2907. +#define DBUS_ERROR_FILE_NOT_FOUND             "org.freedesktop.DBus.Error.FileNotFound"
  2908. +/** Existing file and the operation you're using does not silently overwrite. */
  2909. +#define DBUS_ERROR_FILE_EXISTS                "org.freedesktop.DBus.Error.FileExists"
  2910. +/** Method name you invoked isn't known by the object you invoked it on. */
  2911. +#define DBUS_ERROR_UNKNOWN_METHOD             "org.freedesktop.DBus.Error.UnknownMethod"
  2912. +/** Certain timeout errors, e.g. while starting a service.
  2913. + * @warning this is confusingly-named given that #DBUS_ERROR_TIMEOUT also exists. We can't fix
  2914. + * it for compatibility reasons so just be careful.
  2915. + */
  2916. +#define DBUS_ERROR_TIMED_OUT                  "org.freedesktop.DBus.Error.TimedOut"
  2917. +/** Tried to remove or modify a match rule that didn't exist. */
  2918. +#define DBUS_ERROR_MATCH_RULE_NOT_FOUND       "org.freedesktop.DBus.Error.MatchRuleNotFound"
  2919. +/** The match rule isn't syntactically valid. */
  2920. +#define DBUS_ERROR_MATCH_RULE_INVALID         "org.freedesktop.DBus.Error.MatchRuleInvalid"
  2921. +/** While starting a new process, the exec() call failed. */
  2922. +#define DBUS_ERROR_SPAWN_EXEC_FAILED          "org.freedesktop.DBus.Error.Spawn.ExecFailed"
  2923. +/** While starting a new process, the fork() call failed. */
  2924. +#define DBUS_ERROR_SPAWN_FORK_FAILED          "org.freedesktop.DBus.Error.Spawn.ForkFailed"
  2925. +/** While starting a new process, the child exited with a status code. */
  2926. +#define DBUS_ERROR_SPAWN_CHILD_EXITED         "org.freedesktop.DBus.Error.Spawn.ChildExited"
  2927. +/** While starting a new process, the child exited on a signal. */
  2928. +#define DBUS_ERROR_SPAWN_CHILD_SIGNALED       "org.freedesktop.DBus.Error.Spawn.ChildSignaled"
  2929. +/** While starting a new process, something went wrong. */
  2930. +#define DBUS_ERROR_SPAWN_FAILED               "org.freedesktop.DBus.Error.Spawn.Failed"
  2931. +/** We failed to setup the environment correctly. */
  2932. +#define DBUS_ERROR_SPAWN_SETUP_FAILED         "org.freedesktop.DBus.Error.Spawn.FailedToSetup"
  2933. +/** We failed to setup the config parser correctly. */
  2934. +#define DBUS_ERROR_SPAWN_CONFIG_INVALID       "org.freedesktop.DBus.Error.Spawn.ConfigInvalid"
  2935. +/** Bus name was not valid. */
  2936. +#define DBUS_ERROR_SPAWN_SERVICE_INVALID      "org.freedesktop.DBus.Error.Spawn.ServiceNotValid"
  2937. +/** Service file not found in system-services directory. */
  2938. +#define DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND    "org.freedesktop.DBus.Error.Spawn.ServiceNotFound"
  2939. +/** Permissions are incorrect on the setuid helper. */
  2940. +#define DBUS_ERROR_SPAWN_PERMISSIONS_INVALID  "org.freedesktop.DBus.Error.Spawn.PermissionsInvalid"
  2941. +/** Service file invalid (Name, User or Exec missing). */
  2942. +#define DBUS_ERROR_SPAWN_FILE_INVALID         "org.freedesktop.DBus.Error.Spawn.FileInvalid"
  2943. +/** Tried to get a UNIX process ID and it wasn't available. */
  2944. +#define DBUS_ERROR_SPAWN_NO_MEMORY            "org.freedesktop.DBus.Error.Spawn.NoMemory"
  2945. +/** Tried to get a UNIX process ID and it wasn't available. */
  2946. +#define DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN    "org.freedesktop.DBus.Error.UnixProcessIdUnknown"
  2947. +/** A type signature is not valid. */
  2948. +#define DBUS_ERROR_INVALID_SIGNATURE          "org.freedesktop.DBus.Error.InvalidSignature"
  2949. +/** A file contains invalid syntax or is otherwise broken. */
  2950. +#define DBUS_ERROR_INVALID_FILE_CONTENT       "org.freedesktop.DBus.Error.InvalidFileContent"
  2951. +/** Asked for SELinux security context and it wasn't available. */
  2952. +#define DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN    "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown"
  2953. +/** Asked for ADT audit data and it wasn't available. */
  2954. +#define DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN     "org.freedesktop.DBus.Error.AdtAuditDataUnknown"
  2955. +/** There's already an object with the requested object path. */
  2956. +#define DBUS_ERROR_OBJECT_PATH_IN_USE         "org.freedesktop.DBus.Error.ObjectPathInUse"
  2957. +/** The message meta data does not match the payload. e.g. expected
  2958. +    number of file descriptors were not sent over the socket this message was received on. */
  2959. +#define DBUS_ERROR_INCONSISTENT_MESSAGE       "org.freedesktop.DBus.Error.InconsistentMessage"
  2960. +
  2961. +/* XML introspection format */
  2962. +
  2963. +/** XML namespace of the introspection format version 1.0 */
  2964. +#define DBUS_INTROSPECT_1_0_XML_NAMESPACE         "http://www.freedesktop.org/standards/dbus"
  2965. +/** XML public identifier of the introspection format version 1.0 */
  2966. +#define DBUS_INTROSPECT_1_0_XML_PUBLIC_IDENTIFIER "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
  2967. +/** XML system identifier of the introspection format version 1.0 */
  2968. +#define DBUS_INTROSPECT_1_0_XML_SYSTEM_IDENTIFIER "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd"
  2969. +/** XML document type declaration of the introspection format version 1.0 */
  2970. +#define DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE "<!DOCTYPE node PUBLIC \""DBUS_INTROSPECT_1_0_XML_PUBLIC_IDENTIFIER"\"\n\""DBUS_INTROSPECT_1_0_XML_SYSTEM_IDENTIFIER"\">\n"
  2971. +
  2972. +/** @} */
  2973. +
  2974. +#ifdef __cplusplus
  2975. +#if 0
  2976. +{ /* avoids confusing emacs indentation */
  2977. +#endif
  2978. +}
  2979. +#endif
  2980. +
  2981. +#endif /* DBUS_PROTOCOL_H */
  2982. diff --git a/net/dbus/garbage.c b/net/dbus/garbage.c
  2983. new file mode 100644
  2984. index 0000000..dee0a41
  2985. --- /dev/null
  2986. +++ b/net/dbus/garbage.c
  2987. @@ -0,0 +1,389 @@
  2988. +/*
  2989. + * NET3:       Garbage Collector For AF_DBUS sockets
  2990. + *
  2991. + * Garbage Collector:
  2992. + *     Copyright (C) Barak A. Pearlmutter.
  2993. + *     Released under the GPL version 2 or later.
  2994. + *
  2995. + * Chopped about by Alan Cox 22/3/96 to make it fit the AF_UNIX socket problem.
  2996. + * If it doesn't work blame me, it worked when Barak sent it.
  2997. + *
  2998. + * Assumptions:
  2999. + *
  3000. + *  - object w/ a bit
  3001. + *  - free list
  3002. + *
  3003. + * Current optimizations:
  3004. + *
  3005. + *  - explicit stack instead of recursion
  3006. + *  - tail recurse on first born instead of immediate push/pop
  3007. + *  - we gather the stuff that should not be killed into tree
  3008. + *    and stack is just a path from root to the current pointer.
  3009. + *
  3010. + *  Future optimizations:
  3011. + *
  3012. + *  - don't just push entire root set; process in place
  3013. + *
  3014. + *     This program is free software; you can redistribute it and/or
  3015. + *     modify it under the terms of the GNU General Public License
  3016. + *     as published by the Free Software Foundation; either version
  3017. + *     2 of the License, or (at your option) any later version.
  3018. + *
  3019. + *  Fixes:
  3020. + *     Alan Cox        07 Sept 1997    Vmalloc internal stack as needed.
  3021. + *                                     Cope with changing max_files.
  3022. + *     Al Viro         11 Oct 1998
  3023. + *             Graph may have cycles. That is, we can send the descriptor
  3024. + *             of foo to bar and vice versa. Current code chokes on that.
  3025. + *             Fix: move SCM_RIGHTS ones into the separate list and then
  3026. + *             skb_free() them all instead of doing explicit fput's.
  3027. + *             Another problem: since fput() may block somebody may
  3028. + *             create a new unix_socket when we are in the middle of sweep
  3029. + *             phase. Fix: revert the logic wrt MARKED. Mark everything
  3030. + *             upon the beginning and unmark non-junk ones.
  3031. + *
  3032. + *             [12 Oct 1998] AAARGH! New code purges all SCM_RIGHTS
  3033. + *             sent to connect()'ed but still not accept()'ed sockets.
  3034. + *             Fixed. Old code had slightly different problem here:
  3035. + *             extra fput() in situation when we passed the descriptor via
  3036. + *             such socket and closed it (descriptor). That would happen on
  3037. + *             each unix_gc() until the accept(). Since the struct file in
  3038. + *             question would go to the free list and might be reused...
  3039. + *             That might be the reason of random oopses on filp_close()
  3040. + *             in unrelated processes.
  3041. + *
  3042. + *     AV              28 Feb 1999
  3043. + *             Kill the explicit allocation of stack. Now we keep the tree
  3044. + *             with root in dummy + pointer (gc_current) to one of the nodes.
  3045. + *             Stack is represented as path from gc_current to dummy. Unmark
  3046. + *             now means "add to tree". Push == "make it a son of gc_current".
  3047. + *             Pop == "move gc_current to parent". We keep only pointers to
  3048. + *             parents (->gc_tree).
  3049. + *     AV              1 Mar 1999
  3050. + *             Damn. Added missing check for ->dead in listen queues scanning.
  3051. + *
  3052. + *     Miklos Szeredi 25 Jun 2007
  3053. + *             Reimplement with a cycle collecting algorithm. This should
  3054. + *             solve several problems with the previous code, like being racy
  3055. + *             wrt receive and holding up unrelated socket operations.
  3056. + */
  3057. +
  3058. +#include <linux/kernel.h>
  3059. +#include <linux/string.h>
  3060. +#include <linux/socket.h>
  3061. +#include <linux/un.h>
  3062. +#include <linux/net.h>
  3063. +#include <linux/fs.h>
  3064. +#include <linux/slab.h>
  3065. +#include <linux/skbuff.h>
  3066. +#include <linux/netdevice.h>
  3067. +#include <linux/file.h>
  3068. +#include <linux/proc_fs.h>
  3069. +#include <linux/mutex.h>
  3070. +#include <linux/wait.h>
  3071. +
  3072. +#include <net/sock.h>
  3073. +#include <net/af_dbus.h>
  3074. +#include <net/scm.h>
  3075. +#include <net/tcp_states.h>
  3076. +
  3077. +/* Internal data structures and random procedures: */
  3078. +
  3079. +static LIST_HEAD(gc_inflight_list);
  3080. +static LIST_HEAD(gc_candidates);
  3081. +static DEFINE_SPINLOCK(dbus_gc_lock);
  3082. +static DECLARE_WAIT_QUEUE_HEAD(dbus_gc_wait);
  3083. +
  3084. +unsigned int dbus_tot_inflight;
  3085. +
  3086. +
  3087. +static struct sock *dbus_get_socket(struct file *filp)
  3088. +{
  3089. +       struct sock *u_sock = NULL;
  3090. +       struct inode *inode = filp->f_path.dentry->d_inode;
  3091. +
  3092. +       /*
  3093. +        *      Socket ?
  3094. +        */
  3095. +       if (S_ISSOCK(inode->i_mode)) {
  3096. +               struct socket *sock = SOCKET_I(inode);
  3097. +               struct sock *s = sock->sk;
  3098. +
  3099. +               /*
  3100. +                *      PF_DBUS ?
  3101. +                */
  3102. +               if (s && sock->ops && sock->ops->family == PF_DBUS)
  3103. +                       u_sock = s;
  3104. +       }
  3105. +       return u_sock;
  3106. +}
  3107. +
  3108. +/*
  3109. + *     Keep the number of times in flight count for the file
  3110. + *     descriptor if it is for an AF_DBUS socket.
  3111. + */
  3112. +
  3113. +void dbus_inflight(struct file *fp)
  3114. +{
  3115. +       struct sock *s = dbus_get_socket(fp);
  3116. +       if (s) {
  3117. +               struct dbus_sock *u = dbus_sk(s);
  3118. +               spin_lock(&dbus_gc_lock);
  3119. +               if (atomic_long_inc_return(&u->inflight) == 1) {
  3120. +                       BUG_ON(!list_empty(&u->link));
  3121. +                       list_add_tail(&u->link, &gc_inflight_list);
  3122. +               } else {
  3123. +                       BUG_ON(list_empty(&u->link));
  3124. +               }
  3125. +               dbus_tot_inflight++;
  3126. +               spin_unlock(&dbus_gc_lock);
  3127. +       }
  3128. +}
  3129. +
  3130. +void dbus_notinflight(struct file *fp)
  3131. +{
  3132. +       struct sock *s = dbus_get_socket(fp);
  3133. +       if (s) {
  3134. +               struct dbus_sock *u = dbus_sk(s);
  3135. +               spin_lock(&dbus_gc_lock);
  3136. +               BUG_ON(list_empty(&u->link));
  3137. +               if (atomic_long_dec_and_test(&u->inflight))
  3138. +                       list_del_init(&u->link);
  3139. +               dbus_tot_inflight--;
  3140. +               spin_unlock(&dbus_gc_lock);
  3141. +       }
  3142. +}
  3143. +
  3144. +static inline struct sk_buff *sock_queue_head(struct sock *sk)
  3145. +{
  3146. +       return (struct sk_buff *)&sk->sk_receive_queue;
  3147. +}
  3148. +
  3149. +#define receive_queue_for_each_skb(sk, next, skb) \
  3150. +       for (skb = sock_queue_head(sk)->next, next = skb->next; \
  3151. +            skb != sock_queue_head(sk); skb = next, next = skb->next)
  3152. +
  3153. +static void scan_inflight(struct sock *x, void (*func)(struct dbus_sock *),
  3154. +                         struct sk_buff_head *hitlist)
  3155. +{
  3156. +       struct sk_buff *skb;
  3157. +       struct sk_buff *next;
  3158. +
  3159. +       spin_lock(&x->sk_receive_queue.lock);
  3160. +       receive_queue_for_each_skb(x, next, skb) {
  3161. +               /*
  3162. +                *      Do we have file descriptors ?
  3163. +                */
  3164. +               if (DBUSCB(skb).fp) {
  3165. +                       bool hit = false;
  3166. +                       /*
  3167. +                        *      Process the descriptors of this socket
  3168. +                        */
  3169. +                       int nfd = DBUSCB(skb).fp->count;
  3170. +                       struct file **fp = DBUSCB(skb).fp->fp;
  3171. +                       while (nfd--) {
  3172. +                               /*
  3173. +                                *      Get the socket the fd matches
  3174. +                                *      if it indeed does so
  3175. +                                */
  3176. +                               struct sock *sk = dbus_get_socket(*fp++);
  3177. +                               if (sk) {
  3178. +                                       struct dbus_sock *u = dbus_sk(sk);
  3179. +
  3180. +                                       /*
  3181. +                                        * Ignore non-candidates, they could
  3182. +                                        * have been added to the queues after
  3183. +                                        * starting the garbage collection
  3184. +                                        */
  3185. +                                       if (u->gc_candidate) {
  3186. +                                               hit = true;
  3187. +                                               func(u);
  3188. +                                       }
  3189. +                               }
  3190. +                       }
  3191. +                       if (hit && hitlist != NULL) {
  3192. +                               __skb_unlink(skb, &x->sk_receive_queue);
  3193. +                               __skb_queue_tail(hitlist, skb);
  3194. +                       }
  3195. +               }
  3196. +       }
  3197. +       spin_unlock(&x->sk_receive_queue.lock);
  3198. +}
  3199. +
  3200. +static void scan_children(struct sock *x, void (*func)(struct dbus_sock *),
  3201. +                         struct sk_buff_head *hitlist)
  3202. +{
  3203. +       if (x->sk_state != TCP_LISTEN)
  3204. +               scan_inflight(x, func, hitlist);
  3205. +       else {
  3206. +               struct sk_buff *skb;
  3207. +               struct sk_buff *next;
  3208. +               struct dbus_sock *u;
  3209. +               LIST_HEAD(embryos);
  3210. +
  3211. +               /*
  3212. +                * For a listening socket collect the queued embryos
  3213. +                * and perform a scan on them as well.
  3214. +                */
  3215. +               spin_lock(&x->sk_receive_queue.lock);
  3216. +               receive_queue_for_each_skb(x, next, skb) {
  3217. +                       u = dbus_sk(skb->sk);
  3218. +
  3219. +                       /*
  3220. +                        * An embryo cannot be in-flight, so it's safe
  3221. +                        * to use the list link.
  3222. +                        */
  3223. +                       BUG_ON(!list_empty(&u->link));
  3224. +                       list_add_tail(&u->link, &embryos);
  3225. +               }
  3226. +               spin_unlock(&x->sk_receive_queue.lock);
  3227. +
  3228. +               while (!list_empty(&embryos)) {
  3229. +                       u = list_entry(embryos.next, struct dbus_sock, link);
  3230. +                       scan_inflight(&u->sk, func, hitlist);
  3231. +                       list_del_init(&u->link);
  3232. +               }
  3233. +       }
  3234. +}
  3235. +
  3236. +static void dec_inflight(struct dbus_sock *usk)
  3237. +{
  3238. +       atomic_long_dec(&usk->inflight);
  3239. +}
  3240. +
  3241. +static void inc_inflight(struct dbus_sock *usk)
  3242. +{
  3243. +       atomic_long_inc(&usk->inflight);
  3244. +}
  3245. +
  3246. +static void inc_inflight_move_tail(struct dbus_sock *u)
  3247. +{
  3248. +       atomic_long_inc(&u->inflight);
  3249. +       /*
  3250. +        * If this still might be part of a cycle, move it to the end
  3251. +        * of the list, so that it's checked even if it was already
  3252. +        * passed over
  3253. +        */
  3254. +       if (u->gc_maybe_cycle)
  3255. +               list_move_tail(&u->link, &gc_candidates);
  3256. +}
  3257. +
  3258. +static bool gc_in_progress = false;
  3259. +
  3260. +void wait_for_dbus_gc(void)
  3261. +{
  3262. +       wait_event(dbus_gc_wait, gc_in_progress == false);
  3263. +}
  3264. +
  3265. +/* The external entry point: dbus_gc() */
  3266. +void dbus_gc(void)
  3267. +{
  3268. +       struct dbus_sock *u;
  3269. +       struct dbus_sock *next;
  3270. +       struct sk_buff_head hitlist;
  3271. +       struct list_head cursor;
  3272. +       LIST_HEAD(not_cycle_list);
  3273. +
  3274. +       spin_lock(&dbus_gc_lock);
  3275. +
  3276. +       /* Avoid a recursive GC. */
  3277. +       if (gc_in_progress)
  3278. +               goto out;
  3279. +
  3280. +       gc_in_progress = true;
  3281. +       /*
  3282. +        * First, select candidates for garbage collection.  Only
  3283. +        * in-flight sockets are considered, and from those only ones
  3284. +        * which don't have any external reference.
  3285. +        *
  3286. +        * Holding dbus_gc_lock will protect these candidates from
  3287. +        * being detached, and hence from gaining an external
  3288. +        * reference.  Since there are no possible receivers, all
  3289. +        * buffers currently on the candidates' queues stay there
  3290. +        * during the garbage collection.
  3291. +        *
  3292. +        * We also know that no new candidate can be added onto the
  3293. +        * receive queues.  Other, non candidate sockets _can_ be
  3294. +        * added to queue, so we must make sure only to touch
  3295. +        * candidates.
  3296. +        */
  3297. +       list_for_each_entry_safe(u, next, &gc_inflight_list, link) {
  3298. +               long total_refs;
  3299. +               long inflight_refs;
  3300. +
  3301. +               total_refs = file_count(u->sk.sk_socket->file);
  3302. +               inflight_refs = atomic_long_read(&u->inflight);
  3303. +
  3304. +               BUG_ON(inflight_refs < 1);
  3305. +               BUG_ON(total_refs < inflight_refs);
  3306. +               if (total_refs == inflight_refs) {
  3307. +                       list_move_tail(&u->link, &gc_candidates);
  3308. +                       u->gc_candidate = 1;
  3309. +                       u->gc_maybe_cycle = 1;
  3310. +               }
  3311. +       }
  3312. +
  3313. +       /*
  3314. +        * Now remove all internal in-flight reference to children of
  3315. +        * the candidates.
  3316. +        */
  3317. +       list_for_each_entry(u, &gc_candidates, link)
  3318. +               scan_children(&u->sk, dec_inflight, NULL);
  3319. +
  3320. +       /*
  3321. +        * Restore the references for children of all candidates,
  3322. +        * which have remaining references.  Do this recursively, so
  3323. +        * only those remain, which form cyclic references.
  3324. +        *
  3325. +        * Use a "cursor" link, to make the list traversal safe, even
  3326. +        * though elements might be moved about.
  3327. +        */
  3328. +       list_add(&cursor, &gc_candidates);
  3329. +       while (cursor.next != &gc_candidates) {
  3330. +               u = list_entry(cursor.next, struct dbus_sock, link);
  3331. +
  3332. +               /* Move cursor to after the current position. */
  3333. +               list_move(&cursor, &u->link);
  3334. +
  3335. +               if (atomic_long_read(&u->inflight) > 0) {
  3336. +                       list_move_tail(&u->link, &not_cycle_list);
  3337. +                       u->gc_maybe_cycle = 0;
  3338. +                       scan_children(&u->sk, inc_inflight_move_tail, NULL);
  3339. +               }
  3340. +       }
  3341. +       list_del(&cursor);
  3342. +
  3343. +       /*
  3344. +        * not_cycle_list contains those sockets which do not make up a
  3345. +        * cycle.  Restore these to the inflight list.
  3346. +        */
  3347. +       while (!list_empty(&not_cycle_list)) {
  3348. +               u = list_entry(not_cycle_list.next, struct dbus_sock, link);
  3349. +               u->gc_candidate = 0;
  3350. +               list_move_tail(&u->link, &gc_inflight_list);
  3351. +       }
  3352. +
  3353. +       /*
  3354. +        * Now gc_candidates contains only garbage.  Restore original
  3355. +        * inflight counters for these as well, and remove the skbuffs
  3356. +        * which are creating the cycle(s).
  3357. +        */
  3358. +       skb_queue_head_init(&hitlist);
  3359. +       list_for_each_entry(u, &gc_candidates, link)
  3360. +       scan_children(&u->sk, inc_inflight, &hitlist);
  3361. +
  3362. +       spin_unlock(&dbus_gc_lock);
  3363. +
  3364. +       /* Here we are. Hitlist is filled. Die. */
  3365. +       __skb_queue_purge(&hitlist);
  3366. +
  3367. +       spin_lock(&dbus_gc_lock);
  3368. +
  3369. +       /* All candidates should have been detached by now. */
  3370. +       BUG_ON(!list_empty(&gc_candidates));
  3371. +       gc_in_progress = false;
  3372. +       wake_up(&dbus_gc_wait);
  3373. +
  3374. + out:
  3375. +       spin_unlock(&dbus_gc_lock);
  3376. +}
  3377. diff --git a/net/dbus/matchrule.c b/net/dbus/matchrule.c
  3378. new file mode 100644
  3379. index 0000000..52ebd6b
  3380. --- /dev/null
  3381. +++ b/net/dbus/matchrule.c
  3382. @@ -0,0 +1,1651 @@
  3383. +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
  3384. +/* matchrule.c  D-Bus match rule implementation
  3385. + *
  3386. + * Based on signals.c from dbus
  3387. + *
  3388. + * Copyright (C) 2010  Collabora, Ltd.
  3389. + * Copyright (C) 2003, 2005  Red Hat, Inc.
  3390. + *
  3391. + * Licensed under the Academic Free License version 2.1
  3392. + *
  3393. + * This program is free software; you can redistribute it and/or modify
  3394. + * it under the terms of the GNU General Public License as published by
  3395. + * the Free Software Foundation; either version 2 of the License, or
  3396. + * (at your option) any later version.
  3397. + *
  3398. + * This program is distributed in the hope that it will be useful,
  3399. + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  3400. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  3401. + * GNU General Public License for more details.
  3402. + *
  3403. + * You should have received a copy of the GNU General Public License
  3404. + * along with this program; if not, write to the Free Software
  3405. + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  3406. + *
  3407. + */
  3408. +
  3409. +#include "matchrule.h"
  3410. +
  3411. +#include <linux/rbtree.h>
  3412. +
  3413. +#include "dbus-protocol.h"
  3414. +#include "message.h"
  3415. +
  3416. +struct BusMatchRule
  3417. +{
  3418. +  int refcount;       /**< reference count */
  3419. +
  3420. +  struct dbus_sock *matches_go_to; /**< Owner of the rule */
  3421. +
  3422. +  unsigned int flags; /**< BusMatchFlags */
  3423. +
  3424. +  int   message_type;
  3425. +  char *interface;
  3426. +  char *member;
  3427. +  char *sender;
  3428. +  char *destination;
  3429. +  char *path;
  3430. +
  3431. +  unsigned int *arg_lens;
  3432. +  char **args;
  3433. +  int args_len;
  3434. +
  3435. +  /* BusMatchRule is attached to RulePool, either in a simple double-linked
  3436. +   * list if the rule does not have any interface, or in a red-black tree
  3437. +   * sorted by interface. If several rules can have the same interface, the
  3438. +   * first one is attached with struct rb_node and the next ones are in the
  3439. +   * list */
  3440. +
  3441. +  struct rb_node node;
  3442. +  /* Doubly-linked non-circular list. If the rule has an interface, it is in
  3443. +   * the rb tree and the single head is right here. Otherwise, the single head
  3444. +   * is in RulePool->rules_without_iface. With this datastructure, we don't
  3445. +   * need any allocation to insert or remove the rule. */
  3446. +  struct hlist_head first;
  3447. +  struct hlist_node list;
  3448. +};
  3449. +
  3450. +#define BUS_MATCH_ARG_IS_PATH  0x8000000u
  3451. +
  3452. +#define DBUS_STRING_MAX_LENGTH 1024
  3453. +
  3454. +/** Max length of a match rule string; to keep people from hosing the
  3455. + * daemon with some huge rule
  3456. + */
  3457. +#define DBUS_MAXIMUM_MATCH_RULE_LENGTH 1024
  3458. +
  3459. +BusMatchRule*
  3460. +bus_match_rule_new (struct dbus_sock *matches_go_to)
  3461. +{
  3462. +  BusMatchRule *rule;
  3463. +
  3464. +  rule = kzalloc (sizeof (BusMatchRule), GFP_KERNEL);
  3465. +  if (rule == NULL)
  3466. +    return NULL;
  3467. +
  3468. +  rule->refcount = 1;
  3469. +  rule->matches_go_to = matches_go_to;
  3470. +
  3471. +  WARN_ON (!rule->matches_go_to);
  3472. +  
  3473. +  return rule;
  3474. +}
  3475. +
  3476. +BusMatchRule *
  3477. +bus_match_rule_ref (BusMatchRule *rule)
  3478. +{
  3479. +  WARN_ON (rule->refcount <= 0);
  3480. +
  3481. +  rule->refcount += 1;
  3482. +
  3483. +  return rule;
  3484. +}
  3485. +
  3486. +void
  3487. +bus_match_rule_unref (BusMatchRule *rule)
  3488. +{
  3489. +  WARN_ON (rule->refcount <= 0);
  3490. +
  3491. +  rule->refcount -= 1;
  3492. +  if (rule->refcount == 0)
  3493. +    {
  3494. +      if (rule->interface)
  3495. +        kfree (rule->interface);
  3496. +      if (rule->member)
  3497. +        kfree (rule->member);
  3498. +      if (rule->sender)
  3499. +        kfree (rule->sender);
  3500. +      if (rule->destination)
  3501. +        kfree (rule->destination);
  3502. +      if (rule->path)
  3503. +        kfree (rule->path);
  3504. +      if (rule->arg_lens)
  3505. +        kfree (rule->arg_lens);
  3506. +
  3507. +      /* can't use dbus_free_string_array() since there
  3508. +       * are embedded NULL
  3509. +       */
  3510. +      if (rule->args)
  3511. +        {
  3512. +          int i;
  3513. +
  3514. +          i = 0;
  3515. +          while (i < rule->args_len)
  3516. +            {
  3517. +              if (rule->args[i])
  3518. +                kfree (rule->args[i]);
  3519. +              ++i;
  3520. +            }
  3521. +
  3522. +          kfree (rule->args);
  3523. +        }
  3524. +      
  3525. +      kfree (rule);
  3526. +    }
  3527. +}
  3528. +
  3529. +/* Note this function does not do escaping, so it's only
  3530. + * good for debug spew at the moment
  3531. + */
  3532. +static char*
  3533. +match_rule_to_string (BusMatchRule *rule)
  3534. +{
  3535. +  char *str;
  3536. +  char *cur;
  3537. +  
  3538. +  cur = str = kmalloc (DBUS_STRING_MAX_LENGTH, GFP_KERNEL);
  3539. +  if (!str)
  3540. +    {
  3541. +      return NULL;
  3542. +    }
  3543. +  
  3544. +  if (rule->flags & BUS_MATCH_MESSAGE_TYPE)
  3545. +    {
  3546. +      /* FIXME make type readable */
  3547. +      cur += snprintf(cur, str - cur + DBUS_STRING_MAX_LENGTH,
  3548. +          "type='%d'", rule->message_type);
  3549. +    }
  3550. +
  3551. +  if (rule->flags & BUS_MATCH_INTERFACE)
  3552. +    {
  3553. +      if (cur != str)
  3554. +        {
  3555. +          cur += snprintf(cur, str - cur + DBUS_STRING_MAX_LENGTH,
  3556. +              ",");
  3557. +        }
  3558. +      
  3559. +      cur += snprintf(cur, str - cur + DBUS_STRING_MAX_LENGTH,
  3560. +          "interface='%s'", rule->interface);
  3561. +    }
  3562. +
  3563. +  if (rule->flags & BUS_MATCH_MEMBER)
  3564. +    {
  3565. +      if (cur != str)
  3566. +        {
  3567. +          cur += snprintf(cur, str - cur + DBUS_STRING_MAX_LENGTH,
  3568. +              ",");
  3569. +        }
  3570. +      
  3571. +      cur += snprintf(cur, str - cur + DBUS_STRING_MAX_LENGTH,
  3572. +          "member='%s'", rule->member);
  3573. +    }
  3574. +
  3575. +  if (rule->flags & BUS_MATCH_PATH)
  3576. +    {
  3577. +      if (cur != str)
  3578. +        {
  3579. +          cur += snprintf(cur, str - cur + DBUS_STRING_MAX_LENGTH,
  3580. +              ",");
  3581. +        }
  3582. +      
  3583. +      cur += snprintf(cur, str - cur + DBUS_STRING_MAX_LENGTH,
  3584. +          "path='%s'", rule->path);
  3585. +    }
  3586. +
  3587. +  if (rule->flags & BUS_MATCH_SENDER)
  3588. +    {
  3589. +      if (cur != str)
  3590. +        {
  3591. +          cur += snprintf(cur, str - cur + DBUS_STRING_MAX_LENGTH,
  3592. +              ",");
  3593. +        }
  3594. +      
  3595. +      cur += snprintf(cur, str - cur + DBUS_STRING_MAX_LENGTH,
  3596. +          "sender='%s'", rule->sender);
  3597. +    }
  3598. +
  3599. +  if (rule->flags & BUS_MATCH_DESTINATION)
  3600. +    {
  3601. +      if (cur != str)
  3602. +        {
  3603. +          cur += snprintf(cur, str - cur + DBUS_STRING_MAX_LENGTH,
  3604. +              ",");
  3605. +        }
  3606. +      
  3607. +      cur += snprintf(cur, str - cur + DBUS_STRING_MAX_LENGTH,
  3608. +          "destination='%s'", rule->destination);
  3609. +    }
  3610. +
  3611. +  if (rule->flags & BUS_MATCH_ARGS)
  3612. +    {
  3613. +      int i;
  3614. +      
  3615. +      WARN_ON (!rule->args);
  3616. +
  3617. +      i = 0;
  3618. +      while (i < rule->args_len)
  3619. +        {
  3620. +          if (rule->args[i] != NULL)
  3621. +            {
  3622. +              int is_path;
  3623. +
  3624. +              if (cur != str)
  3625. +                {
  3626. +                  cur += snprintf(cur, str - cur + DBUS_STRING_MAX_LENGTH,
  3627. +                      ",");
  3628. +                }
  3629. +
  3630. +              is_path = (rule->arg_lens[i] & BUS_MATCH_ARG_IS_PATH) != 0;
  3631. +              
  3632. +              cur += snprintf(cur, str - cur + DBUS_STRING_MAX_LENGTH,
  3633. +                  "arg%d%s='%s'", i, is_path ? "path" : "",
  3634. +                  rule->args[i]);
  3635. +            }
  3636. +          
  3637. +          ++i;
  3638. +        }
  3639. +    }
  3640. +  
  3641. +  return str;
  3642. +}
  3643. +
  3644. +int
  3645. +bus_match_rule_set_message_type (BusMatchRule *rule,
  3646. +                                 int           type)
  3647. +{
  3648. +  rule->flags |= BUS_MATCH_MESSAGE_TYPE;
  3649. +
  3650. +  rule->message_type = type;
  3651. +
  3652. +  return 1;
  3653. +}
  3654. +
  3655. +int
  3656. +bus_match_rule_set_interface (BusMatchRule *rule,
  3657. +                              const char   *interface)
  3658. +{
  3659. +  char *new;
  3660. +
  3661. +  WARN_ON (!interface);
  3662. +
  3663. +  new = kstrdup (interface, GFP_KERNEL);
  3664. +  if (new == NULL)
  3665. +    return 0;
  3666. +
  3667. +  rule->flags |= BUS_MATCH_INTERFACE;
  3668. +  kfree (rule->interface);
  3669. +  rule->interface = new;
  3670. +
  3671. +  return 1;
  3672. +}
  3673. +
  3674. +int
  3675. +bus_match_rule_set_member (BusMatchRule *rule,
  3676. +                           const char   *member)
  3677. +{
  3678. +  char *new;
  3679. +
  3680. +  WARN_ON(!member);
  3681. +
  3682. +  new = kstrdup (member, GFP_KERNEL);
  3683. +  if (new == NULL)
  3684. +    return 0;
  3685. +
  3686. +  rule->flags |= BUS_MATCH_MEMBER;
  3687. +  kfree (rule->member);
  3688. +  rule->member = new;
  3689. +
  3690. +  return 1;
  3691. +}
  3692. +
  3693. +int
  3694. +bus_match_rule_set_sender (BusMatchRule *rule,
  3695. +                           const char   *sender)
  3696. +{
  3697. +  char *new;
  3698. +
  3699. +  WARN_ON (!sender);
  3700. +
  3701. +  new = kstrdup (sender, GFP_KERNEL);
  3702. +  if (new == NULL)
  3703. +    return 0;
  3704. +
  3705. +  rule->flags |= BUS_MATCH_SENDER;
  3706. +  kfree (rule->sender);
  3707. +  rule->sender = new;
  3708. +
  3709. +  return 1;
  3710. +}
  3711. +
  3712. +int
  3713. +bus_match_rule_set_destination (BusMatchRule *rule,
  3714. +                                const char   *destination)
  3715. +{
  3716. +  char *new;
  3717. +
  3718. +  WARN_ON (!destination);
  3719. +
  3720. +  new = kstrdup (destination, GFP_KERNEL);
  3721. +  if (new == NULL)
  3722. +    return 0;
  3723. +
  3724. +  rule->flags |= BUS_MATCH_DESTINATION;
  3725. +  kfree (rule->destination);
  3726. +  rule->destination = new;
  3727. +
  3728. +  return 1;
  3729. +}
  3730. +
  3731. +int
  3732. +bus_match_rule_set_path (BusMatchRule *rule,
  3733. +                         const char   *path)
  3734. +{
  3735. +  char *new;
  3736. +
  3737. +  WARN_ON (!path);
  3738. +
  3739. +  new = kstrdup (path, GFP_KERNEL);
  3740. +  if (new == NULL)
  3741. +    return 0;
  3742. +
  3743. +  rule->flags |= BUS_MATCH_PATH;
  3744. +  kfree (rule->path);
  3745. +  rule->path = new;
  3746. +
  3747. +  return 1;
  3748. +}
  3749. +
  3750. +int
  3751. +bus_match_rule_set_arg (BusMatchRule     *rule,
  3752. +                        int                arg,
  3753. +                        const char *value,
  3754. +                        int       is_path)
  3755. +{
  3756. +  int length;
  3757. +  char *new;
  3758. +
  3759. +  /* args_len is the number of args not including null termination
  3760. +   * in the char**
  3761. +   */
  3762. +  if (arg >= rule->args_len)
  3763. +    {
  3764. +      unsigned int *new_arg_lens;
  3765. +      char **new_args;
  3766. +      int new_args_len;
  3767. +      int i;
  3768. +
  3769. +      new_args_len = arg + 1;
  3770. +
  3771. +      /* add another + 1 here for null termination */
  3772. +      new_args = krealloc (rule->args,
  3773. +          sizeof (char *) * (new_args_len + 1), GFP_KERNEL);
  3774. +      if (new_args == NULL)
  3775. +        return 0;
  3776. +
  3777. +      /* NULL the new slots */
  3778. +      i = rule->args_len;
  3779. +      while (i <= new_args_len) /* <= for null termination */
  3780. +        {
  3781. +          new_args[i] = NULL;
  3782. +          ++i;
  3783. +        }
  3784. +      
  3785. +      rule->args = new_args;
  3786. +
  3787. +      /* and now add to the lengths */
  3788. +      new_arg_lens = krealloc (rule->arg_lens,
  3789. +          sizeof (int) * (new_args_len + 1), GFP_KERNEL);
  3790. +
  3791. +      if (new_arg_lens == NULL)
  3792. +        return 0;
  3793. +
  3794. +      /* zero the new slots */
  3795. +      i = rule->args_len;
  3796. +      while (i <= new_args_len) /* <= for null termination */
  3797. +        {
  3798. +          new_arg_lens[i] = 0;
  3799. +          ++i;
  3800. +        }
  3801. +
  3802. +      rule->arg_lens = new_arg_lens;
  3803. +      rule->args_len = new_args_len;
  3804. +    }
  3805. +
  3806. +  length = strlen (value);
  3807. +  if (!(new = kstrdup (value, GFP_KERNEL)))
  3808. +    return 0;
  3809. +
  3810. +  rule->flags |= BUS_MATCH_ARGS;
  3811. +
  3812. +  kfree (rule->args[arg]);
  3813. +  rule->arg_lens[arg] = length;
  3814. +  rule->args[arg] = new;
  3815. +
  3816. +  if (is_path)
  3817. +    rule->arg_lens[arg] |= BUS_MATCH_ARG_IS_PATH;
  3818. +
  3819. +  return 1;
  3820. +}
  3821. +
  3822. +#define ISWHITE(c) (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || ((c) == '\r'))
  3823. +
  3824. +static int
  3825. +find_key (const char *str,
  3826. +          int               start,
  3827. +          char             *key,
  3828. +          int              *value_pos)
  3829. +{
  3830. +  const char *p;
  3831. +  const char *s;
  3832. +  const char *key_start;
  3833. +  const char *key_end;
  3834. +
  3835. +  s = str;
  3836. +
  3837. +  p = s + start;
  3838. +
  3839. +  while (*p && ISWHITE (*p))
  3840. +    ++p;
  3841. +
  3842. +  key_start = p;
  3843. +
  3844. +  while (*p && *p != '=' && !ISWHITE (*p))
  3845. +    ++p;
  3846. +
  3847. +  key_end = p;
  3848. +
  3849. +  while (*p && ISWHITE (*p))
  3850. +    ++p;
  3851. +  
  3852. +  if (key_start == key_end)
  3853. +    {
  3854. +      /* Empty match rules or trailing whitespace are OK */
  3855. +      *value_pos = p - s;
  3856. +      return 1;
  3857. +    }
  3858. +
  3859. +  if (*p != '=')
  3860. +    {
  3861. +      pr_warning("Match rule has a key with no subsequent '=' character");
  3862. +      return 0;
  3863. +    }
  3864. +  ++p;
  3865. +  
  3866. +  strncat (key, key_start, key_end - key_start);
  3867. +
  3868. +  *value_pos = p - s;
  3869. +  
  3870. +  return 1;
  3871. +}
  3872. +
  3873. +static int
  3874. +find_value (const char       *str,
  3875. +            int               start,
  3876. +            const char       *key,
  3877. +            char             *value,
  3878. +            int              *value_end)
  3879. +{
  3880. +  const char *p;
  3881. +  const char *s;
  3882. +  char quote_char;
  3883. +  int orig_len;
  3884. +
  3885. +  orig_len = strlen (value);
  3886. +  
  3887. +  s = str;
  3888. +
  3889. +  p = s + start;
  3890. +
  3891. +  quote_char = '\0';
  3892. +
  3893. +  while (*p)
  3894. +    {
  3895. +      if (quote_char == '\0')
  3896. +        {
  3897. +          switch (*p)
  3898. +            {
  3899. +            case '\0':
  3900. +              goto done;
  3901. +
  3902. +            case '\'':
  3903. +              quote_char = '\'';
  3904. +              goto next;
  3905. +              
  3906. +            case ',':
  3907. +              ++p;
  3908. +              goto done;
  3909. +
  3910. +            case '\\':
  3911. +              quote_char = '\\';
  3912. +              goto next;
  3913. +              
  3914. +            default:
  3915. +              strncat(value, p, 1);
  3916. +            }
  3917. +        }
  3918. +      else if (quote_char == '\\')
  3919. +        {
  3920. +          /* \ only counts as an escape if escaping a quote mark */
  3921. +          if (*p != '\'')
  3922. +            {
  3923. +              strncat(value, "\\", 1);
  3924. +            }
  3925. +
  3926. +          strncat(value, p, 1);
  3927. +          
  3928. +          quote_char = '\0';
  3929. +        }
  3930. +      else
  3931. +        {
  3932. +          if (*p == '\'')
  3933. +            {
  3934. +              quote_char = '\0';
  3935. +            }
  3936. +          else
  3937. +            {
  3938. +              strncat(value, p, 1);
  3939. +            }
  3940. +        }
  3941. +
  3942. +    next:
  3943. +      ++p;
  3944. +    }
  3945. +
  3946. + done:
  3947. +
  3948. +  if (quote_char == '\\')
  3949. +    {
  3950. +      strncat(value, "\\", 1);
  3951. +    }
  3952. +  else if (quote_char == '\'')
  3953. +    {
  3954. +      pr_warning ("Unbalanced quotation marks in match rule");
  3955. +      return 0;
  3956. +    }
  3957. +
  3958. +  /* Zero-length values are allowed */
  3959. +  
  3960. +  *value_end = p - s;
  3961. +  
  3962. +  return 1;
  3963. +}
  3964. +
  3965. +/* duplicates aren't allowed so the real legitimate max is only 6 or
  3966. + * so. Leaving extra so we don't have to bother to update it.
  3967. + * FIXME this is sort of busted now with arg matching, but we let
  3968. + * you match on up to 10 args for now
  3969. + */
  3970. +#define MAX_RULE_TOKENS 16
  3971. +
  3972. +/* this is slightly too high level to be termed a "token"
  3973. + * but let's not be pedantic.
  3974. + */
  3975. +typedef struct
  3976. +{
  3977. +  char *key;
  3978. +  char *value;
  3979. +} RuleToken;
  3980. +
  3981. +static int
  3982. +tokenize_rule (const char *rule_text,
  3983. +               RuleToken         tokens[MAX_RULE_TOKENS])
  3984. +{
  3985. +  int i;
  3986. +  int pos;
  3987. +  int retval;
  3988. +
  3989. +  retval = 0;
  3990. +  
  3991. +  i = 0;
  3992. +  pos = 0;
  3993. +  while (i < MAX_RULE_TOKENS &&
  3994. +         pos < strlen (rule_text))
  3995. +    {
  3996. +      char *key;
  3997. +      char *value;
  3998. +
  3999. +      key = kzalloc (DBUS_STRING_MAX_LENGTH, GFP_KERNEL);
  4000. +      if (!key)
  4001. +        {
  4002. +          printk("Out of memory");
  4003. +          BUG();
  4004. +          return 0;
  4005. +        }
  4006. +
  4007. +      value = kzalloc (DBUS_STRING_MAX_LENGTH, GFP_KERNEL);
  4008. +      if (!value)
  4009. +        {
  4010. +          kfree(key);
  4011. +          printk("Out of memory");
  4012. +          BUG();
  4013. +          return 0;
  4014. +        }
  4015. +
  4016. +      if (!find_key (rule_text, pos, key, &pos))
  4017. +        goto out;
  4018. +
  4019. +      if (strlen (key) == 0)
  4020. +        goto next;
  4021. +      
  4022. +      tokens[i].key = key;
  4023. +
  4024. +      if (!find_value (rule_text, pos, tokens[i].key, value, &pos))
  4025. +        goto out;
  4026. +
  4027. +      tokens[i].value = value;
  4028. +
  4029. +    next:
  4030. +      ++i;
  4031. +    }
  4032. +
  4033. +  retval = 1;
  4034. +  
  4035. + out:
  4036. +  if (!retval)
  4037. +    {
  4038. +      i = 0;
  4039. +      while (tokens[i].key || tokens[i].value)
  4040. +        {
  4041. +          kfree (tokens[i].key);
  4042. +          kfree (tokens[i].value);
  4043. +          tokens[i].key = NULL;
  4044. +          tokens[i].value = NULL;
  4045. +          ++i;
  4046. +        }
  4047. +    }
  4048. +  
  4049. +  return retval;
  4050. +}
  4051. +
  4052. +#if 0
  4053. +static int
  4054. +bus_match_rule_parse_arg_match (BusMatchRule     *rule,
  4055. +                                const char       *key,
  4056. +                                const char       *value)
  4057. +{
  4058. +  int is_path;
  4059. +  DBusString key_str;
  4060. +  unsigned long arg;
  4061. +  int length;
  4062. +  int end;
  4063. +
  4064. +  /* For now, arg0='foo' always implies that 'foo' is a
  4065. +   * DBUS_TYPE_STRING. Someday we could add an arg0type='int32' thing
  4066. +   * if we wanted, which would specify another type, in which case
  4067. +   * arg0='5' would have the 5 parsed as an int rather than string.
  4068. +   */
  4069. +  
  4070. +  /* First we need to parse arg0 = 0, arg27 = 27 */
  4071. +
  4072. +  _dbus_string_init_const (&key_str, key);
  4073. +  length = _dbus_string_get_length (&key_str);
  4074. +
  4075. +  if (_dbus_string_get_length (&key_str) < 4)
  4076. +    {
  4077. +      dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
  4078. +                      "Key '%s' in match rule starts with 'arg' but lacks an arg number. Should be 'arg0' or 'arg7' for example.\n", key);
  4079. +      goto failed;
  4080. +    }
  4081. +
  4082. +  if (!_dbus_string_parse_uint (&key_str, 3, &arg, &end))
  4083. +    {
  4084. +      dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
  4085. +                      "Key '%s' in match rule starts with 'arg' but could not parse arg number. Should be 'arg0' or 'arg7' for example.\n", key);
  4086. +      goto failed;
  4087. +    }
  4088. +
  4089. +  if (end != length &&
  4090. +      ((end + 4) != length ||
  4091. +       !_dbus_string_ends_with_c_str (&key_str, "path")))
  4092. +    {
  4093. +      dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
  4094. +                      "Key '%s' in match rule contains junk after argument number. Only 'path' is optionally valid ('arg0path' for example).\n", key);
  4095. +      goto failed;
  4096. +    }
  4097. +
  4098. +  is_path = end != length;
  4099. +
  4100. +  /* If we didn't check this we could allocate a huge amount of RAM */
  4101. +  if (arg > DBUS_MAXIMUM_MATCH_RULE_ARG_NUMBER)
  4102. +    {
  4103. +      printk("Key '%s' in match rule has arg number %lu but the maximum is %d.\n", key, (unsigned long) arg, DBUS_MAXIMUM_MATCH_RULE_ARG_NUMBER);
  4104. +      dump_stack();
  4105. +      return 0;
  4106. +    }
  4107. +  
  4108. +  if ((rule->flags & BUS_MATCH_ARGS) &&
  4109. +      rule->args_len > (int) arg &&
  4110. +      rule->args[arg] != NULL)
  4111. +    {
  4112. +      printk("Argument %d matched more than once in match rule\n", key);
  4113. +      dump_stack();
  4114. +      return 0;
  4115. +    }
  4116. +  
  4117. +  if (!bus_match_rule_set_arg (rule, arg, value, is_path))
  4118. +    {
  4119. +      printk("Out of memory");
  4120. +      dump_stack();
  4121. +      return 0;
  4122. +    }
  4123. +
  4124. +  return 1;
  4125. +}
  4126. +#endif
  4127. +
  4128. +/*
  4129. + * The format is comma-separated with strings quoted with single quotes
  4130. + * as for the shell (to escape a literal single quote, use '\'').
  4131. + *
  4132. + * type='signal',sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',member='Foo',
  4133. + * path='/bar/foo',destination=':452345.34'
  4134. + *
  4135. + */
  4136. +BusMatchRule*
  4137. +bus_match_rule_parse (struct dbus_sock   *matches_go_to,
  4138. +                      const char         *rule_text)
  4139. +{
  4140. +  BusMatchRule *rule;
  4141. +  RuleToken tokens[MAX_RULE_TOKENS+1]; /* NULL termination + 1 */
  4142. +  int i;
  4143. +  
  4144. +  if (strlen (rule_text) > DBUS_MAXIMUM_MATCH_RULE_LENGTH)
  4145. +    {
  4146. +      pr_warning ("Match rule text is %d bytes, maximum is %d",
  4147. +                      strlen (rule_text),
  4148. +                      DBUS_MAXIMUM_MATCH_RULE_LENGTH);
  4149. +      return NULL;
  4150. +    }
  4151. +  
  4152. +  memset (tokens, '\0', sizeof (tokens));
  4153. +  
  4154. +  rule = bus_match_rule_new (matches_go_to);
  4155. +  if (rule == NULL)
  4156. +    {
  4157. +      printk("Out of memory");
  4158. +      BUG();
  4159. +      goto failed;
  4160. +    }
  4161. +  
  4162. +  if (!tokenize_rule (rule_text, tokens))
  4163. +    goto failed;
  4164. +  
  4165. +  i = 0;
  4166. +  while (tokens[i].key != NULL)
  4167. +    {
  4168. +#if 0
  4169. +      char *tmp_str;
  4170. +      int len;
  4171. +#endif
  4172. +      const char *key = tokens[i].key;
  4173. +      const char *value = tokens[i].value;
  4174. +      
  4175. +#if 0
  4176. +      tmp_str = value;
  4177. +      len = strlen (tmp_str);
  4178. +#endif
  4179. +
  4180. +      if (strcmp (key, "type") == 0)
  4181. +        {
  4182. +          int t;
  4183. +
  4184. +          if (rule->flags & BUS_MATCH_MESSAGE_TYPE)
  4185. +            {
  4186. +              pr_warning("Key %s specified twice in match rule\n", key);
  4187. +              goto failed;
  4188. +            }
  4189. +          
  4190. +          t = dbus_message_type_from_string (value);
  4191. +          
  4192. +          if (t == DBUS_MESSAGE_TYPE_INVALID)
  4193. +            {
  4194. +              pr_warning("Invalid message type (%s) in match rule\n", value);
  4195. +              goto failed;
  4196. +            }
  4197. +
  4198. +          if (!bus_match_rule_set_message_type (rule, t))
  4199. +            {
  4200. +              printk("Out of memeory");
  4201. +              BUG();
  4202. +              goto failed;
  4203. +            }
  4204. +        }
  4205. +      else if (strcmp (key, "sender") == 0)
  4206. +        {
  4207. +          if (rule->flags & BUS_MATCH_SENDER)
  4208. +            {
  4209. +              pr_warning("Key %s specified twice in match rule\n", key);
  4210. +              goto failed;
  4211. +            }
  4212. +
  4213. +#if 0
  4214. +          if (!_dbus_validate_bus_name (tmp_str, 0, len))
  4215. +            {
  4216. +              dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
  4217. +                              "Sender name '%s' is invalid\n", value);
  4218. +              goto failed;
  4219. +            }
  4220. +#endif
  4221. +
  4222. +          if (!bus_match_rule_set_sender (rule, value))
  4223. +            {
  4224. +              printk("Out of memeory");
  4225. +              BUG();
  4226. +              goto failed;
  4227. +            }
  4228. +        }
  4229. +      else if (strcmp (key, "interface") == 0)
  4230. +        {
  4231. +          if (rule->flags & BUS_MATCH_INTERFACE)
  4232. +            {
  4233. +              pr_warning("Key %s specified twice in match rule\n", key);
  4234. +              goto failed;
  4235. +            }
  4236. +
  4237. +#if 0
  4238. +          if (!_dbus_validate_interface (tmp_str, 0, len))
  4239. +            {
  4240. +              dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
  4241. +                              "Interface name '%s' is invalid\n", value);
  4242. +              goto failed;
  4243. +            }
  4244. +#endif
  4245. +
  4246. +          if (!bus_match_rule_set_interface (rule, value))
  4247. +            {
  4248. +              printk("Out of memeory");
  4249. +              BUG();
  4250. +              goto failed;
  4251. +            }
  4252. +        }
  4253. +      else if (strcmp (key, "member") == 0)
  4254. +        {
  4255. +          if (rule->flags & BUS_MATCH_MEMBER)
  4256. +            {
  4257. +              pr_warning("Key %s specified twice in match rule\n", key);
  4258. +              goto failed;
  4259. +            }
  4260. +
  4261. +#if 0
  4262. +          if (!_dbus_validate_member (tmp_str, 0, len))
  4263. +            {
  4264. +              dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
  4265. +                              "Member name '%s' is invalid\n", value);
  4266. +              goto failed;
  4267. +            }
  4268. +#endif
  4269. +
  4270. +          if (!bus_match_rule_set_member (rule, value))
  4271. +            {
  4272. +              printk("Out of memeory");
  4273. +              BUG();
  4274. +              goto failed;
  4275. +            }
  4276. +        }
  4277. +      else if (strcmp (key, "path") == 0)
  4278. +        {
  4279. +          if (rule->flags & BUS_MATCH_PATH)
  4280. +            {
  4281. +              pr_warning("Key %s specified twice in match rule\n", key);
  4282. +              goto failed;
  4283. +            }
  4284. +
  4285. +#if 0
  4286. +          if (!_dbus_validate_path (tmp_str, 0, len))
  4287. +            {
  4288. +              dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
  4289. +                              "Path '%s' is invalid\n", value);
  4290. +              goto failed;
  4291. +            }
  4292. +#endif
  4293. +
  4294. +          if (!bus_match_rule_set_path (rule, value))
  4295. +            {
  4296. +              printk("Out of memeory");
  4297. +              BUG();
  4298. +              goto failed;
  4299. +            }
  4300. +        }
  4301. +      else if (strcmp (key, "destination") == 0)
  4302. +        {
  4303. +          if (rule->flags & BUS_MATCH_DESTINATION)
  4304. +            {
  4305. +              pr_warning("Key %s specified twice in match rule\n", key);
  4306. +              goto failed;
  4307. +            }
  4308. +
  4309. +#if 0
  4310. +          if (!_dbus_validate_bus_name (tmp_str, 0, len))
  4311. +            {
  4312. +              dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
  4313. +                              "Destination name '%s' is invalid\n", value);
  4314. +              goto failed;
  4315. +            }
  4316. +#endif
  4317. +
  4318. +          if (!bus_match_rule_set_destination (rule, value))
  4319. +            {
  4320. +              printk("Out of memeory");
  4321. +              BUG();
  4322. +              goto failed;
  4323. +            }
  4324. +        }
  4325. +      else if (strncmp (key, "arg", 3) == 0)
  4326. +        {
  4327. +#if 0
  4328. +          if (!bus_match_rule_parse_arg_match (rule, key, &tmp_str, error))
  4329. +            goto failed;
  4330. +#endif
  4331. +        }
  4332. +      else
  4333. +        {
  4334. +          pr_warning("Unknown key \"%s\" in match rule\n",
  4335. +                          key);
  4336. +          goto failed;
  4337. +        }
  4338. +
  4339. +      ++i;
  4340. +    }
  4341. +  
  4342. +
  4343. +  goto out;
  4344. +  
  4345. + failed:
  4346. +  if (rule)
  4347. +    {
  4348. +      bus_match_rule_unref (rule);
  4349. +      rule = NULL;
  4350. +    }
  4351. +
  4352. + out:
  4353. +  
  4354. +  i = 0;
  4355. +  while (tokens[i].key || tokens[i].value)
  4356. +    {
  4357. +      WARN_ON (i >= MAX_RULE_TOKENS);
  4358. +      kfree (tokens[i].key);
  4359. +      kfree (tokens[i].value);
  4360. +      ++i;
  4361. +    }
  4362. +  
  4363. +  return rule;
  4364. +}
  4365. +
  4366. +typedef struct RulePool RulePool;
  4367. +struct RulePool
  4368. +{
  4369. +  /* Maps non-NULL interface names to a list of BusMatchRule */
  4370. +  struct rb_root rules_by_iface;
  4371. +
  4372. +  /* List of BusMatchRules which don't specify an interface */
  4373. +  struct hlist_head rules_without_iface;
  4374. +};
  4375. +
  4376. +struct BusMatchmaker
  4377. +{
  4378. +  int refcount;
  4379. +
  4380. +  /* Pools of rules, grouped by the type of message they match. 0
  4381. +   * (DBUS_MESSAGE_TYPE_INVALID) represents rules that do not specify a message
  4382. +   * type.
  4383. +   */
  4384. +  RulePool rules_by_type[DBUS_NUM_MESSAGE_TYPES];
  4385. +};
  4386. +
  4387. +/* return the match rule containing the hlist_head. It may not be the first
  4388. + * match rule in the list. */
  4389. +struct BusMatchRule *match_rule_search(struct rb_root *root, const char *interface)
  4390. +{
  4391. +      struct rb_node *node = root->rb_node;
  4392. +
  4393. +      while (node) {
  4394. +              struct BusMatchRule *data = container_of(node,
  4395. +                  struct BusMatchRule, node);
  4396. +              int result;
  4397. +
  4398. +              result = strcmp(interface, data->interface);
  4399. +
  4400. +              if (result < 0)
  4401. +                      node = node->rb_left;
  4402. +              else if (result > 0)
  4403. +                      node = node->rb_right;
  4404. +              else
  4405. +                      return data;
  4406. +      }
  4407. +      return NULL;
  4408. +}
  4409. +
  4410. +void match_rule_insert(struct rb_root *root, struct BusMatchRule *data)
  4411. +{
  4412. +      struct rb_node **new = &(root->rb_node), *parent = NULL;
  4413. +
  4414. +      /* Figure out where to put new node */
  4415. +      while (*new) {
  4416. +              struct BusMatchRule *this = container_of(*new,
  4417. +                  struct BusMatchRule, node);
  4418. +              int result = strcmp(data->interface, this->interface);
  4419. +
  4420. +              parent = *new;
  4421. +              if (result < 0)
  4422. +                      new = &((*new)->rb_left);
  4423. +              else if (result > 0)
  4424. +                      new = &((*new)->rb_right);
  4425. +              else {
  4426. +                      /* the head is not used */
  4427. +                      INIT_HLIST_HEAD(&data->first);
  4428. +                      /* Add it at the beginning of the list */
  4429. +                      hlist_add_head(&data->list, &this->first);
  4430. +                      return;
  4431. +              }
  4432. +      }
  4433. +
  4434. +      /* this rule is single in its list */
  4435. +      INIT_HLIST_HEAD(&data->first);
  4436. +      hlist_add_head(&data->list, &data->first);
  4437. +
  4438. +      /* Add new node and rebalance tree. */
  4439. +      rb_link_node(&data->node, parent, new);
  4440. +      rb_insert_color(&data->node, root);
  4441. +}
  4442. +
  4443. +BusMatchmaker*
  4444. +bus_matchmaker_new (void)
  4445. +{
  4446. +  BusMatchmaker *matchmaker;
  4447. +  int i;
  4448. +
  4449. +  matchmaker = kzalloc (sizeof (BusMatchmaker), GFP_KERNEL);
  4450. +  if (matchmaker == NULL)
  4451. +    return NULL;
  4452. +
  4453. +  matchmaker->refcount = 1;
  4454. +
  4455. +  for (i = DBUS_MESSAGE_TYPE_INVALID; i < DBUS_NUM_MESSAGE_TYPES; i++)
  4456. +    {
  4457. +      RulePool *p = matchmaker->rules_by_type + i;
  4458. +
  4459. +      p->rules_by_iface = RB_ROOT;
  4460. +    }
  4461. +
  4462. +  return matchmaker;
  4463. +}
  4464. +
  4465. +BusMatchmaker *
  4466. +bus_matchmaker_ref (BusMatchmaker *matchmaker)
  4467. +{
  4468. +  WARN_ON (matchmaker->refcount <= 0);
  4469. +
  4470. +  matchmaker->refcount += 1;
  4471. +
  4472. +  return matchmaker;
  4473. +}
  4474. +
  4475. +void
  4476. +bus_matchmaker_unref (BusMatchmaker *matchmaker)
  4477. +{
  4478. +  WARN_ON (matchmaker->refcount <= 0);
  4479. +
  4480. +  matchmaker->refcount -= 1;
  4481. +  if (matchmaker->refcount == 0)
  4482. +    {
  4483. +      // FIXME: LEAK!!
  4484. +      kfree (matchmaker);
  4485. +    }
  4486. +}
  4487. +
  4488. +/* The rule can't be modified after it's added. */
  4489. +int
  4490. +bus_matchmaker_add_rule (BusMatchmaker   *matchmaker,
  4491. +                         BusMatchRule    *rule)
  4492. +{
  4493. +  RulePool *pool;
  4494. +
  4495. +  WARN_ON (rule->message_type < 0);
  4496. +  WARN_ON (rule->message_type >= DBUS_NUM_MESSAGE_TYPES);
  4497. +
  4498. +  pool = matchmaker->rules_by_type + rule->message_type;
  4499. +
  4500. +  if (rule->interface) {
  4501. +    match_rule_insert (&pool->rules_by_iface, rule);
  4502. +  } else {
  4503. +    hlist_add_head(&rule->list, &pool->rules_without_iface);
  4504. +  }
  4505. +  
  4506. +  return 1;
  4507. +}
  4508. +
  4509. +static int
  4510. +match_rule_equal (BusMatchRule *a,
  4511. +                  BusMatchRule *b)
  4512. +{
  4513. +  if (a->flags != b->flags)
  4514. +    return 0;
  4515. +
  4516. +  if (a->matches_go_to != b->matches_go_to)
  4517. +    return 0;
  4518. +
  4519. +  if ((a->flags & BUS_MATCH_MESSAGE_TYPE) &&
  4520. +      a->message_type != b->message_type)
  4521. +    return 0;
  4522. +
  4523. +  if ((a->flags & BUS_MATCH_MEMBER) &&
  4524. +      strcmp (a->member, b->member) != 0)
  4525. +    return 0;
  4526. +
  4527. +  if ((a->flags & BUS_MATCH_PATH) &&
  4528. +      strcmp (a->path, b->path) != 0)
  4529. +    return 0;
  4530. +  
  4531. +  if ((a->flags & BUS_MATCH_INTERFACE) &&
  4532. +      strcmp (a->interface, b->interface) != 0)
  4533. +    return 0;
  4534. +
  4535. +  if ((a->flags & BUS_MATCH_SENDER) &&
  4536. +      strcmp (a->sender, b->sender) != 0)
  4537. +    return 0;
  4538. +
  4539. +  if ((a->flags & BUS_MATCH_DESTINATION) &&
  4540. +      strcmp (a->destination, b->destination) != 0)
  4541. +    return 0;
  4542. +
  4543. +  if (a->flags & BUS_MATCH_ARGS)
  4544. +    {
  4545. +      int i;
  4546. +      
  4547. +      if (a->args_len != b->args_len)
  4548. +        return 0;
  4549. +      
  4550. +      i = 0;
  4551. +      while (i < a->args_len)
  4552. +        {
  4553. +          int length;
  4554. +
  4555. +          if ((a->args[i] != NULL) != (b->args[i] != NULL))
  4556. +            return 0;
  4557. +
  4558. +          if (a->arg_lens[i] != b->arg_lens[i])
  4559. +            return 0;
  4560. +
  4561. +          length = a->arg_lens[i] & ~BUS_MATCH_ARG_IS_PATH;
  4562. +
  4563. +          if (a->args[i] != NULL)
  4564. +            {
  4565. +              WARN_ON (!b->args[i]);
  4566. +              if (memcmp (a->args[i], b->args[i], length) != 0)
  4567. +                return 0;
  4568. +            }
  4569. +          
  4570. +          ++i;
  4571. +        }
  4572. +    }
  4573. +  
  4574. +  return 1;
  4575. +}
  4576. +
  4577. +void
  4578. +bus_matchmaker_remove_rule (BusMatchmaker   *matchmaker,
  4579. +                            BusMatchRule    *rule)
  4580. +{
  4581. +  RulePool *pool;
  4582. +
  4583. +  WARN_ON (rule->message_type < 0);
  4584. +  WARN_ON (rule->message_type >= DBUS_NUM_MESSAGE_TYPES);
  4585. +
  4586. +  pool = matchmaker->rules_by_type + rule->message_type;
  4587. +
  4588. +  if (rule->interface) {
  4589. +    BusMatchRule *head = match_rule_search(&pool->rules_by_iface,
  4590. +        rule->interface);
  4591. +    hlist_del(&rule->list);
  4592. +    if (!hlist_empty(&head->first) && head == rule) {
  4593. +      BusMatchRule *next = hlist_entry(head->first.first,
  4594. +          BusMatchRule, list);
  4595. +      hlist_move_list(&head->first, &next->first);
  4596. +    }
  4597. +    //XXX what _if we need to remove the rb_node entry: rb_erase
  4598. +  } else {
  4599. +    hlist_del(&rule->list);
  4600. +  }
  4601. +  //bus_match_rule_unref (rule); // cf XXX
  4602. +}
  4603. +
  4604. +/* Remove a single rule which is equal to the given rule by value */
  4605. +void
  4606. +bus_matchmaker_remove_rule_by_value (BusMatchmaker   *matchmaker,
  4607. +                                     BusMatchRule    *rule)
  4608. +{
  4609. +  RulePool *pool;
  4610. +
  4611. +  WARN_ON (rule->message_type < 0);
  4612. +  WARN_ON (rule->message_type >= DBUS_NUM_MESSAGE_TYPES);
  4613. +
  4614. +  pool = matchmaker->rules_by_type + rule->message_type;
  4615. +
  4616. +  if (rule->interface) {
  4617. +    BusMatchRule *head = match_rule_search(&pool->rules_by_iface,
  4618. +        rule->interface);
  4619. +    hlist_del(&rule->list);
  4620. +    if (!hlist_empty(&head->first) && match_rule_equal(head, rule)) {
  4621. +      BusMatchRule *next = hlist_entry(head->first.first,
  4622. +          BusMatchRule, list);
  4623. +      hlist_move_list(&head->first, &next->first);
  4624. +    }
  4625. +  } else {
  4626. +    hlist_del(&rule->list);
  4627. +  }
  4628. +  //bus_match_rule_unref (rule); // cf XXX
  4629. +}
  4630. +
  4631. +static void
  4632. +rule_list_remove_by_connection (BusMatchmaker *matchmaker,
  4633. +                                struct hlist_head *rules,
  4634. +                                struct dbus_sock  *connection)
  4635. +{
  4636. +  struct hlist_node *cur, *next;
  4637. +  BusMatchRule *rule;
  4638. +
  4639. +  if (rules == NULL)
  4640. +    return;
  4641. +
  4642. +  hlist_for_each_entry_safe(rule, cur, next, rules, list)
  4643. +    {
  4644. +      char *s = match_rule_to_string (rule);
  4645. +
  4646. +      if (rule->matches_go_to == connection) {
  4647. +        pr_debug("Delete rule \"%s\" because it is the owner of the rule\n", s);
  4648. +        kfree(s);
  4649. +        bus_matchmaker_remove_rule(matchmaker, rule);
  4650. +      } else if (((rule->flags & BUS_MATCH_SENDER) && *rule->sender == ':') ||
  4651. +                 ((rule->flags & BUS_MATCH_DESTINATION) && *rule->destination == ':')) {
  4652. +        /* The rule matches to/from a base service, see if it's the
  4653. +         * one being disconnected, since we know this service name
  4654. +         * will never be recycled.
  4655. +         */
  4656. +        const char *name;
  4657. +
  4658. +        name = connection->uniq_name;
  4659. +        if (!name)
  4660. +          {
  4661. +            kfree(s);
  4662. +            continue;
  4663. +          }
  4664. +
  4665. +        if (((rule->flags & BUS_MATCH_SENDER) &&
  4666. +             strcmp (rule->sender, name) == 0) ||
  4667. +            ((rule->flags & BUS_MATCH_DESTINATION) &&
  4668. +             strcmp (rule->destination, name) == 0))
  4669. +          {
  4670. +            pr_debug("Delete rule \"%s\" because of sender or destination\n", s);
  4671. +            bus_matchmaker_remove_rule(matchmaker, rule);
  4672. +          }
  4673. +        kfree(s);
  4674. +      }
  4675. +
  4676. +    }
  4677. +}
  4678. +
  4679. +void
  4680. +bus_matchmaker_disconnected (BusMatchmaker   *matchmaker,
  4681. +                             struct dbus_sock  *connection)
  4682. +{
  4683. +  int i;
  4684. +
  4685. +  /* FIXME
  4686. +   *
  4687. +   * This scans all match rules on the bus. We could avoid that
  4688. +   * for the rules belonging to the connection, since we keep
  4689. +   * a list of those; but for the rules that just refer to
  4690. +   * the connection we'd need to do something more elaborate.
  4691. +   */
  4692. +
  4693. +  pr_debug ("Removing all rules for connection '%s'\n",
  4694. +      connection->uniq_name ? connection->uniq_name : "(null)");
  4695. +  for (i = 0; i < MAX_WELL_KNOWN_NAMES; i++)
  4696. +    if (connection->well_known_names[i])
  4697. +      pr_debug(" - including well known name '%s'\n",
  4698. +          connection->well_known_names[i]);
  4699. +
  4700. +  for (i = DBUS_MESSAGE_TYPE_INVALID; i < DBUS_NUM_MESSAGE_TYPES; i++)
  4701. +    {
  4702. +      RulePool *p = matchmaker->rules_by_type + i;
  4703. +      struct rb_node *node;
  4704. +
  4705. +      rule_list_remove_by_connection (matchmaker,
  4706. +          &p->rules_without_iface, connection);
  4707. +
  4708. +      for (node = rb_first(&p->rules_by_iface); node; node = rb_next(node)) {
  4709. +        pr_debug("interface=%s\n",
  4710. +            rb_entry(node, struct BusMatchRule, node)->interface);
  4711. +        rule_list_remove_by_connection (matchmaker,
  4712. +            &rb_entry(node, struct BusMatchRule, node)->first, connection);
  4713. +      }
  4714. +    }
  4715. +
  4716. +  pr_debug("bus_matchmaker_disconnected: Finished :-)\n");
  4717. +}
  4718. +
  4719. +static int
  4720. +connection_is_primary_owner (struct dbus_sock *connection,
  4721. +                             const char     *service_name)
  4722. +{
  4723. +#if 0
  4724. +  BusService *service;
  4725. +  DBusString str;
  4726. +  BusRegistry *registry;
  4727. +
  4728. +  _dbus_assert (connection != NULL);
  4729. +  
  4730. +  registry = bus_connection_get_registry (connection);
  4731. +
  4732. +  _dbus_string_init_const (&str, service_name);
  4733. +  service = bus_registry_lookup (registry, &str);
  4734. +
  4735. +  if (service == NULL)
  4736. +    return 0; /* Service doesn't exist so connection can't own it. */
  4737. +
  4738. +  return bus_service_get_primary_owners_connection (service) == connection;
  4739. +#endif
  4740. +  return 1;
  4741. +}
  4742. +
  4743. +static int
  4744. +match_rule_matches (BusMatchRule    *rule,
  4745. +                    struct dbus_sock  *sender,
  4746. +                    struct dbus_sock  *addressed_recipient,
  4747. +                    const struct DBusMessage     *message,
  4748. +                    BusMatchFlags    already_matched)
  4749. +{
  4750. +  int flags;
  4751. +
  4752. +  /* All features of the match rule are AND'd together,
  4753. +   * so 0 if any of them don't match.
  4754. +   */
  4755. +
  4756. +  /* sender/addressed_recipient of #NULL may mean bus driver,
  4757. +   * or for addressed_recipient may mean a message with no
  4758. +   * specific recipient (i.e. a signal)
  4759. +   */
  4760. +
  4761. +  /* Don't bother re-matching features we've already checked implicitly. */
  4762. +  flags = rule->flags & (~already_matched);
  4763. +
  4764. +  if (flags & BUS_MATCH_MESSAGE_TYPE)
  4765. +    {
  4766. +      WARN_ON (rule->message_type == DBUS_MESSAGE_TYPE_INVALID);
  4767. +
  4768. +      if (rule->message_type != message->type)
  4769. +        return 0;
  4770. +    }
  4771. +
  4772. +  if (flags & BUS_MATCH_INTERFACE)
  4773. +    {
  4774. +      const char *iface;
  4775. +
  4776. +      WARN_ON (!rule->interface);
  4777. +
  4778. +      iface = message->interface;
  4779. +      if (iface == NULL)
  4780. +        return 0;
  4781. +
  4782. +      if (strcmp (iface, rule->interface) != 0)
  4783. +        return 0;
  4784. +    }
  4785. +
  4786. +  if (flags & BUS_MATCH_MEMBER)
  4787. +    {
  4788. +      const char *member;
  4789. +
  4790. +      WARN_ON (!rule->member);
  4791. +
  4792. +      member = message->member;
  4793. +      if (member == NULL)
  4794. +        return 0;
  4795. +
  4796. +      if (strcmp (member, rule->member) != 0)
  4797. +        return 0;
  4798. +    }
  4799. +
  4800. +  if (flags & BUS_MATCH_SENDER)
  4801. +    {
  4802. +      WARN_ON (!rule->sender);
  4803. +
  4804. +      if (sender == NULL)
  4805. +        {
  4806. +          if (strcmp (rule->sender,
  4807. +                      "org.freedesktop.DBus") != 0)
  4808. +            return 0;
  4809. +        }
  4810. +      else
  4811. +        {
  4812. +          if (!connection_is_primary_owner (sender, rule->sender))
  4813. +            return 0;
  4814. +        }
  4815. +    }
  4816. +
  4817. +  if (flags & BUS_MATCH_DESTINATION)
  4818. +    {
  4819. +      const char *destination;
  4820. +
  4821. +      WARN_ON (!rule->destination);
  4822. +
  4823. +      destination = message->destination;
  4824. +      if (destination == NULL)
  4825. +        return 0;
  4826. +
  4827. +      if (addressed_recipient == NULL)
  4828. +        {          
  4829. +          if (strcmp (rule->destination,
  4830. +                      "org.freedesktop.DBus") != 0)
  4831. +            return 0;
  4832. +        }
  4833. +      else
  4834. +        {
  4835. +          if (!connection_is_primary_owner (addressed_recipient, rule->destination))
  4836. +            return 0;
  4837. +        }
  4838. +    }
  4839. +
  4840. +  if (flags & BUS_MATCH_PATH)
  4841. +    {
  4842. +      const char *path;
  4843. +
  4844. +      WARN_ON (!rule->path);
  4845. +
  4846. +      path = message->path;
  4847. +      if (path == NULL)
  4848. +        return 0;
  4849. +
  4850. +      if (strcmp (path, rule->path) != 0)
  4851. +        return 0;
  4852. +    }
  4853. +
  4854. +#if 0
  4855. +  if (flags & BUS_MATCH_ARGS)
  4856. +    {
  4857. +      int i;
  4858. +      DBusMessageIter iter;
  4859. +      
  4860. +      _dbus_assert (rule->args != NULL);
  4861. +
  4862. +      dbus_message_iter_init (message, &iter);
  4863. +      
  4864. +      i = 0;
  4865. +      while (i < rule->args_len)
  4866. +        {
  4867. +          int current_type;
  4868. +          const char *expected_arg;
  4869. +          int expected_length;
  4870. +          int is_path;
  4871. +
  4872. +          expected_arg = rule->args[i];
  4873. +          expected_length = rule->arg_lens[i] & ~BUS_MATCH_ARG_IS_PATH;
  4874. +          is_path = (rule->arg_lens[i] & BUS_MATCH_ARG_IS_PATH) != 0;
  4875. +          
  4876. +          current_type = dbus_message_iter_get_arg_type (&iter);
  4877. +
  4878. +          if (expected_arg != NULL)
  4879. +            {
  4880. +              const char *actual_arg;
  4881. +              int actual_length;
  4882. +              
  4883. +              if (current_type != DBUS_TYPE_STRING)
  4884. +                return 0;
  4885. +
  4886. +              actual_arg = NULL;
  4887. +              dbus_message_iter_get_basic (&iter, &actual_arg);
  4888. +              _dbus_assert (actual_arg != NULL);
  4889. +
  4890. +              actual_length = strlen (actual_arg);
  4891. +
  4892. +              if (is_path)
  4893. +                {
  4894. +                  if (actual_length < expected_length &&
  4895. +                      actual_arg[actual_length - 1] != '/')
  4896. +                    return 0;
  4897. +
  4898. +                  if (expected_length < actual_length &&
  4899. +                      expected_arg[expected_length - 1] != '/')
  4900. +                    return 0;
  4901. +
  4902. +                  if (memcmp (actual_arg, expected_arg,
  4903. +                              MIN (actual_length, expected_length)) != 0)
  4904. +                    return 0;
  4905. +                }
  4906. +              else
  4907. +                {
  4908. +                  if (expected_length != actual_length ||
  4909. +                      memcmp (expected_arg, actual_arg, expected_length) != 0)
  4910. +                    return 0;
  4911. +                }
  4912. +
  4913. +            }
  4914. +          
  4915. +          if (current_type != DBUS_TYPE_INVALID)
  4916. +            dbus_message_iter_next (&iter);
  4917. +
  4918. +          ++i;
  4919. +        }
  4920. +    }
  4921. +#endif
  4922. +  
  4923. +  return 1;
  4924. +}
  4925. +
  4926. +static void
  4927. +get_recipients_from_list (struct hlist_head *rules,
  4928. +                          struct dbus_sock  *sender,
  4929. +                          struct dbus_sock  *addressed_recipient,
  4930. +                          const struct DBusMessage     *message,
  4931. +                          deliver_func_t deliver_func,
  4932. +                          void *user_data)
  4933. +{
  4934. +  struct hlist_node *cur;
  4935. +  BusMatchRule *rule;
  4936. +
  4937. +  if (rules == NULL)
  4938. +    return;
  4939. +
  4940. +  hlist_for_each_entry(rule, cur, rules, list)
  4941. +    {
  4942. +      char *s = match_rule_to_string (rule);
  4943. +
  4944. +
  4945. +      if (match_rule_matches (rule,
  4946. +                              sender, addressed_recipient, message,
  4947. +                              BUS_MATCH_MESSAGE_TYPE | BUS_MATCH_INTERFACE))
  4948. +        {
  4949. +          pr_debug ("  [YES] deliver to '%s' with match rule \"%s\"\n",
  4950. +              rule->matches_go_to->uniq_name ?
  4951. +              rule->matches_go_to->uniq_name : "(null)", s);
  4952. +          if (deliver_func)
  4953. +            deliver_func ((struct sock *)(rule->matches_go_to), user_data);
  4954. +        }
  4955. +      else
  4956. +        {
  4957. +          pr_debug ("  [NO]  deliver to '%s' with match rule \"%s\"\n",
  4958. +              rule->matches_go_to->uniq_name ?
  4959. +              rule->matches_go_to->uniq_name : "(null)", s);
  4960. +        }
  4961. +      kfree (s);
  4962. +    }
  4963. +}
  4964. +
  4965. +static struct hlist_head *
  4966. +bus_matchmaker_get_rules (BusMatchmaker *matchmaker,
  4967. +                          int            message_type,
  4968. +                          const char    *interface)
  4969. +{
  4970. +  static struct hlist_head empty = {0,};
  4971. +  RulePool *p;
  4972. +
  4973. +  WARN_ON (message_type < 0);
  4974. +  WARN_ON (message_type >= DBUS_NUM_MESSAGE_TYPES);
  4975. +
  4976. +  p = matchmaker->rules_by_type + message_type;
  4977. +
  4978. +  if (interface == NULL)
  4979. +    {
  4980. +      return &p->rules_without_iface;
  4981. +    }
  4982. +  else
  4983. +    {
  4984. +      BusMatchRule *rule = match_rule_search (&p->rules_by_iface,
  4985. +        interface);
  4986. +      if (rule)
  4987. +        return &rule->first;
  4988. +      else
  4989. +        return &empty;
  4990. +    }
  4991. +}
  4992. +
  4993. +void
  4994. +bus_matchmaker_get_recipients (BusMatchmaker   *matchmaker,
  4995. +                               struct dbus_sock  *sender,
  4996. +                               struct dbus_sock  *addressed_recipient,
  4997. +                               const struct DBusMessage     *message,
  4998. +                               deliver_func_t deliver_func,
  4999. +                               void *user_data)
  5000. +{
  5001. +  int type;
  5002. +  const char *interface;
  5003. +  struct hlist_head *neither, *just_type, *just_iface, *both;
  5004. +
  5005. +  type = message->type;
  5006. +  interface = message->interface;
  5007. +
  5008. +  neither = bus_matchmaker_get_rules (matchmaker, DBUS_MESSAGE_TYPE_INVALID,
  5009. +      NULL);
  5010. +  just_type = just_iface = both = NULL;
  5011. +
  5012. +  if (interface != NULL)
  5013. +    just_iface = bus_matchmaker_get_rules (matchmaker,
  5014. +        DBUS_MESSAGE_TYPE_INVALID, interface);
  5015. +
  5016. +  if (type > DBUS_MESSAGE_TYPE_INVALID && type < DBUS_NUM_MESSAGE_TYPES)
  5017. +    {
  5018. +      just_type = bus_matchmaker_get_rules (matchmaker, type, NULL);
  5019. +
  5020. +      if (interface != NULL)
  5021. +        both = bus_matchmaker_get_rules (matchmaker, type, interface);
  5022. +    }
  5023. +
  5024. +  get_recipients_from_list (neither, sender, addressed_recipient,
  5025. +      message, deliver_func, user_data);
  5026. +  get_recipients_from_list (just_iface, sender, addressed_recipient,
  5027. +      message, deliver_func, user_data);
  5028. +  get_recipients_from_list (just_type, sender, addressed_recipient,
  5029. +      message, deliver_func, user_data);
  5030. +  get_recipients_from_list (both, sender, addressed_recipient,
  5031. +      message, deliver_func, user_data);
  5032. +}
  5033. +
  5034. diff --git a/net/dbus/matchrule.h b/net/dbus/matchrule.h
  5035. new file mode 100644
  5036. index 0000000..d8de5d6
  5037. --- /dev/null
  5038. +++ b/net/dbus/matchrule.h
  5039. @@ -0,0 +1,92 @@
  5040. +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
  5041. +/* signals.h  Bus signal connection implementation
  5042. + *
  5043. + * Copyright (C) 2003  Red Hat, Inc.
  5044. + *
  5045. + * Licensed under the Academic Free License version 2.1
  5046. + *
  5047. + * This program is free software; you can redistribute it and/or modify
  5048. + * it under the terms of the GNU General Public License as published by
  5049. + * the Free Software Foundation; either version 2 of the License, or
  5050. + * (at your option) any later version.
  5051. + *
  5052. + * This program is distributed in the hope that it will be useful,
  5053. + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  5054. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  5055. + * GNU General Public License for more details.
  5056. + *
  5057. + * You should have received a copy of the GNU General Public License
  5058. + * along with this program; if not, write to the Free Software
  5059. + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  5060. + *
  5061. + */
  5062. +
  5063. +#ifndef BUS_SIGNALS_H
  5064. +#define BUS_SIGNALS_H
  5065. +
  5066. +#include <net/af_dbus.h>
  5067. +#include <linux/list.h>
  5068. +
  5069. +#include "message.h"
  5070. +
  5071. +typedef struct BusMatchRule    BusMatchRule;
  5072. +typedef struct BusMatchmaker    BusMatchmaker;
  5073. +
  5074. +typedef enum
  5075. +{
  5076. +  BUS_MATCH_MESSAGE_TYPE = 1 << 0,
  5077. +  BUS_MATCH_INTERFACE    = 1 << 1,
  5078. +  BUS_MATCH_MEMBER       = 1 << 2,
  5079. +  BUS_MATCH_SENDER       = 1 << 3,
  5080. +  BUS_MATCH_DESTINATION  = 1 << 4,
  5081. +  BUS_MATCH_PATH         = 1 << 5,
  5082. +  BUS_MATCH_ARGS         = 1 << 6
  5083. +} BusMatchFlags;
  5084. +
  5085. +BusMatchRule* bus_match_rule_new   (struct dbus_sock *matches_go_to);
  5086. +BusMatchRule* bus_match_rule_ref   (BusMatchRule   *rule);
  5087. +void          bus_match_rule_unref (BusMatchRule   *rule);
  5088. +
  5089. +int bus_match_rule_set_message_type (BusMatchRule     *rule,
  5090. +                                             int               type);
  5091. +int bus_match_rule_set_interface    (BusMatchRule     *rule,
  5092. +                                             const char       *interface);
  5093. +int bus_match_rule_set_member       (BusMatchRule     *rule,
  5094. +                                             const char       *member);
  5095. +int bus_match_rule_set_sender       (BusMatchRule     *rule,
  5096. +                                             const char       *sender);
  5097. +int bus_match_rule_set_destination  (BusMatchRule     *rule,
  5098. +                                             const char       *destination);
  5099. +int bus_match_rule_set_path         (BusMatchRule     *rule,
  5100. +                                             const char       *path);
  5101. +int bus_match_rule_set_arg          (BusMatchRule     *rule,
  5102. +                                             int               arg,
  5103. +                                             const char       *value,
  5104. +                                             int       is_path);
  5105. +
  5106. +BusMatchRule* bus_match_rule_parse (struct dbus_sock   *matches_go_to,
  5107. +                                    const char         *rule_text);
  5108. +
  5109. +BusMatchmaker* bus_matchmaker_new   (void);
  5110. +BusMatchmaker* bus_matchmaker_ref   (BusMatchmaker *matchmaker);
  5111. +void           bus_matchmaker_unref (BusMatchmaker *matchmaker);
  5112. +
  5113. +int bus_matchmaker_add_rule             (BusMatchmaker   *matchmaker,
  5114. +                                                 BusMatchRule    *rule);
  5115. +void bus_matchmaker_remove_rule_by_value (BusMatchmaker   *matchmaker,
  5116. +                                                 BusMatchRule    *value);
  5117. +void        bus_matchmaker_remove_rule          (BusMatchmaker   *matchmaker,
  5118. +                                                 BusMatchRule    *rule);
  5119. +void        bus_matchmaker_disconnected         (BusMatchmaker   *matchmaker,
  5120. +                                                 struct dbus_sock  *connection);
  5121. +
  5122. +typedef void (*deliver_func_t) (struct sock *dest, void *user_data);
  5123. +
  5124. +void bus_matchmaker_get_recipients       (BusMatchmaker   *matchmaker,
  5125. +                                                 struct dbus_sock  *sender,
  5126. +                                                 struct dbus_sock  *addressed_recipient,
  5127. +                                                 const struct DBusMessage *message,
  5128. +                                                 deliver_func_t deliver_func,
  5129. +                                                 void *user_data);
  5130. +
  5131. +#endif /* BUS_SIGNALS_H */
  5132. diff --git a/net/dbus/message.c b/net/dbus/message.c
  5133. new file mode 100644
  5134. index 0000000..17233d3
  5135. --- /dev/null
  5136. +++ b/net/dbus/message.c
  5137. @@ -0,0 +1,274 @@
  5138. +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
  5139. +/* message.c  Basic D-Bus message parsing
  5140. + *
  5141. + * Copyright (C) 2010  Collabora Ltd
  5142. + * Authors:    Alban Crequy <alban.crequy@collabora.co.uk>
  5143. + * Copyright (C) 2002, 2003, 2004, 2005  Red Hat Inc.
  5144. + * Copyright (C) 2002, 2003  CodeFactory AB
  5145. + *
  5146. + * Licensed under the Academic Free License version 2.1
  5147. + *
  5148. + *
  5149. + * This program is free software; you can redistribute it and/or modify
  5150. + * it under the terms of the GNU General Public License as published by
  5151. + * the Free Software Foundation; either version 2 of the License, or
  5152. + * (at your option) any later version.
  5153. + *
  5154. + * This program is distributed in the hope that it will be useful,
  5155. + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  5156. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  5157. + * GNU General Public License for more details.
  5158. + *
  5159. + * You should have received a copy of the GNU General Public License
  5160. + * along with this program; if not, write to the Free Software
  5161. + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  5162. + *
  5163. + */
  5164. +
  5165. +#include "message.h"
  5166. +#include "dbus-protocol.h"
  5167. +
  5168. +/**
  5169. + * Utility function to convert a machine-readable (not translated)
  5170. + * string into a D-Bus message type.
  5171. + *
  5172. + * @code
  5173. + *   "method_call"    -> DBUS_MESSAGE_TYPE_METHOD_CALL
  5174. + *   "method_return"  -> DBUS_MESSAGE_TYPE_METHOD_RETURN
  5175. + *   "signal"         -> DBUS_MESSAGE_TYPE_SIGNAL
  5176. + *   "error"          -> DBUS_MESSAGE_TYPE_ERROR
  5177. + *   anything else    -> DBUS_MESSAGE_TYPE_INVALID
  5178. + * @endcode
  5179. + *
  5180. + */
  5181. +int
  5182. +dbus_message_type_from_string (const char *type_str)
  5183. +{
  5184. +  if (strcmp (type_str, "method_call") == 0)
  5185. +    return DBUS_MESSAGE_TYPE_METHOD_CALL;
  5186. +  if (strcmp (type_str, "method_return") == 0)
  5187. +    return DBUS_MESSAGE_TYPE_METHOD_RETURN;
  5188. +  else if (strcmp (type_str, "signal") == 0)
  5189. +    return DBUS_MESSAGE_TYPE_SIGNAL;
  5190. +  else if (strcmp (type_str, "error") == 0)
  5191. +    return DBUS_MESSAGE_TYPE_ERROR;
  5192. +  else
  5193. +    return DBUS_MESSAGE_TYPE_INVALID;
  5194. +}
  5195. +
  5196. +/**
  5197. + * Utility function to convert a D-Bus message type into a
  5198. + * machine-readable string (not translated).
  5199. + *
  5200. + * @code
  5201. + *   DBUS_MESSAGE_TYPE_METHOD_CALL    -> "method_call"
  5202. + *   DBUS_MESSAGE_TYPE_METHOD_RETURN  -> "method_return"
  5203. + *   DBUS_MESSAGE_TYPE_SIGNAL         -> "signal"
  5204. + *   DBUS_MESSAGE_TYPE_ERROR          -> "error"
  5205. + *   DBUS_MESSAGE_TYPE_INVALID        -> "invalid"
  5206. + * @endcode
  5207. + *
  5208. + */
  5209. +const char *
  5210. +dbus_message_type_to_string (int type)
  5211. +{
  5212. +  switch (type)
  5213. +    {
  5214. +    case DBUS_MESSAGE_TYPE_METHOD_CALL:
  5215. +      return "method_call";
  5216. +    case DBUS_MESSAGE_TYPE_METHOD_RETURN:
  5217. +      return "method_return";
  5218. +    case DBUS_MESSAGE_TYPE_SIGNAL:
  5219. +      return "signal";
  5220. +    case DBUS_MESSAGE_TYPE_ERROR:
  5221. +      return "error";
  5222. +    default:
  5223. +      return "invalid";
  5224. +    }
  5225. +}
  5226. +
  5227. +int dbus_message_parse(unsigned char *message, size_t len,
  5228. +    struct DBusMessage *dbus_message)
  5229. +{
  5230. +       unsigned char *cur;
  5231. +       int array_header_len;
  5232. +
  5233. +       dbus_message->message = message;
  5234. +
  5235. +       if (len < 4 + 4 + 4 + 4 || message[1] == 0 || message[1] > 4) {
  5236. +               return -EINVAL;
  5237. +       }
  5238. +       dbus_message->type = message[1];
  5239. +       dbus_message->body_length = *((u32 *)(message + 4));
  5240. +       cur = message + 12;
  5241. +       array_header_len = *(u32 *)cur;
  5242. +       dbus_message->len_offset = 12;
  5243. +       cur += 4;
  5244. +       while (cur < message + len
  5245. +           && cur < message + 12 + 4 + array_header_len) {
  5246. +               int header_code;
  5247. +               int signature_len;
  5248. +               unsigned char *signature;
  5249. +               int str_len;
  5250. +               unsigned char *str;
  5251. +
  5252. +               /* D-Bus alignment craziness */
  5253. +               if ((cur - message) % 8 != 0)
  5254. +                       cur += 8 - (cur - message) % 8;
  5255. +
  5256. +               header_code = *(char *)cur;
  5257. +               cur++;
  5258. +               signature_len = *(char *)cur;
  5259. +               /* All header fields of the current D-Bus spec have a simple
  5260. +                * type, either o, s, g, or u */
  5261. +               if (signature_len != 1)
  5262. +                       return -EINVAL;
  5263. +               cur++;
  5264. +               signature = cur;
  5265. +               cur += signature_len + 1;
  5266. +               if (signature[0] != 'o' &&
  5267. +                   signature[0] != 's' &&
  5268. +                   signature[0] != 'g' &&
  5269. +                   signature[0] != 'u')
  5270. +                 return -EINVAL;
  5271. +
  5272. +               if (signature[0] == 'u') {
  5273. +                       cur += 4;
  5274. +                       continue;
  5275. +               }
  5276. +
  5277. +               if (signature[0] != 'g') {
  5278. +                       str_len = *(u32 *)cur;
  5279. +                       cur += 4;
  5280. +               } else {
  5281. +                       str_len = *(char *)cur;
  5282. +                       cur += 1;
  5283. +               }
  5284. +
  5285. +               str = cur;
  5286. +               switch (header_code) {
  5287. +                       case 1: dbus_message->path = str;
  5288. +                               break;
  5289. +                       case 2: dbus_message->interface = str;
  5290. +                               break;
  5291. +                       case 3: dbus_message->member = str;
  5292. +                               break;
  5293. +                       case 6: dbus_message->destination = str;
  5294. +                               break;
  5295. +                       case 7: dbus_message->sender = str;
  5296. +                               break;
  5297. +                       case 8: dbus_message->body_signature = str;
  5298. +                               break;
  5299. +               }
  5300. +               cur += str_len + 1;
  5301. +       }
  5302. +
  5303. +       dbus_message->padding_end = (8 - (cur - message) % 8) % 8;
  5304. +
  5305. +        /* Jump to body D-Bus alignment craziness */
  5306. +        if ((cur - message) % 8 != 0)
  5307. +               cur += 8 - (cur - message) % 8;
  5308. +       dbus_message->new_header_offset = cur - message;
  5309. +
  5310. +       if (dbus_message->new_header_offset
  5311. +            + dbus_message->body_length != len) {
  5312. +               pr_warning("Message truncated? "
  5313. +                    "Header %d + Body %d != Length %zd\n",
  5314. +                    dbus_message->new_header_offset,
  5315. +                    dbus_message->body_length, len);
  5316. +               return -EINVAL;
  5317. +       }
  5318. +
  5319. +       if (dbus_message->body_signature &&
  5320. +            dbus_message->body_signature[0] == 's') {
  5321. +               int str_len;
  5322. +                str_len = *(u32 *)cur;
  5323. +                cur += 4;
  5324. +               dbus_message->arg0 = cur;
  5325. +               cur += str_len + 1;
  5326. +       }
  5327. +
  5328. +        if ((cur - message) % 4 != 0)
  5329. +               cur += 4 - (cur - message) % 4;
  5330. +
  5331. +       if (dbus_message->body_signature &&
  5332. +            dbus_message->body_signature[0] == 's' &&
  5333. +            dbus_message->body_signature[1] == 's') {
  5334. +               int str_len;
  5335. +                str_len = *(u32 *)cur;
  5336. +                cur += 4;
  5337. +               dbus_message->arg1 = cur;
  5338. +               cur += str_len + 1;
  5339. +       }
  5340. +
  5341. +        if ((cur - message) % 4 != 0)
  5342. +               cur += 4 - (cur - message) % 4;
  5343. +
  5344. +       if (dbus_message->body_signature &&
  5345. +            dbus_message->body_signature[0] == 's' &&
  5346. +            dbus_message->body_signature[1] == 's' &&
  5347. +            dbus_message->body_signature[2] == 's') {
  5348. +               int str_len;
  5349. +                str_len = *(u32 *)cur;
  5350. +                cur += 4;
  5351. +               dbus_message->arg2 = cur;
  5352. +               cur += str_len + 1;
  5353. +       }
  5354. +
  5355. +        if ((cur - message) % 4 != 0)
  5356. +               cur += 4 - (cur - message) % 4;
  5357. +
  5358. +       return 0;
  5359. +}
  5360. +
  5361. +
  5362. +int
  5363. +dbus_message_add_sender(struct DBusMessage *dbus_message,
  5364. +    const char *sender, gfp_t gfp_flags)
  5365. +{
  5366. +       unsigned char *message = dbus_message->message;
  5367. +       unsigned char *new_message;
  5368. +       int added_size_not_aligned = 1 + 3 + 4 +
  5369. +          strlen(sender) + 1;
  5370. +       int added_size = added_size_not_aligned
  5371. +          + (8 - added_size_not_aligned % 8) % 8;
  5372. +
  5373. +       dbus_message->new_len = dbus_message->len + added_size;
  5374. +       new_message = kmalloc(dbus_message->new_len, gfp_flags);
  5375. +        if (!new_message)
  5376. +               return -ENOMEM;
  5377. +
  5378. +       memcpy(new_message, message, dbus_message->new_header_offset);
  5379. +       *(char*)(new_message + dbus_message->new_header_offset)
  5380. +          = 7;
  5381. +       *(char*)(new_message + dbus_message->new_header_offset + 1)
  5382. +          = 1;
  5383. +       *(char*)(new_message + dbus_message->new_header_offset + 2)
  5384. +          = 's';
  5385. +       *(char*)(new_message + dbus_message->new_header_offset + 3)
  5386. +          = '\0';
  5387. +       *(u32*)(new_message + dbus_message->new_header_offset + 4)
  5388. +          = strlen(sender);
  5389. +
  5390. +       BUG_ON(dbus_message->sender != NULL);
  5391. +       dbus_message->sender = new_message + dbus_message->new_header_offset
  5392. +            + 1 + 3 + 4;
  5393. +       strcpy(dbus_message->sender, sender);
  5394. +       memset(new_message + dbus_message->new_header_offset
  5395. +            + added_size_not_aligned, 0,
  5396. +            added_size - added_size_not_aligned);
  5397. +       memcpy(new_message + dbus_message->new_header_offset
  5398. +            + added_size,
  5399. +            message + dbus_message->new_header_offset,
  5400. +            dbus_message->len - dbus_message->new_header_offset);
  5401. +
  5402. +       *(u32*)(new_message + dbus_message->len_offset) =
  5403. +          *(u32*)(new_message + dbus_message->len_offset) +
  5404. +          dbus_message->padding_end + added_size_not_aligned;
  5405. +
  5406. +       kfree(message);
  5407. +       dbus_message_parse(new_message, dbus_message->new_len, dbus_message);
  5408. +
  5409. +       return 0;
  5410. +}
  5411. +
  5412. diff --git a/net/dbus/message.h b/net/dbus/message.h
  5413. new file mode 100644
  5414. index 0000000..263e5d5
  5415. --- /dev/null
  5416. +++ b/net/dbus/message.h
  5417. @@ -0,0 +1,64 @@
  5418. +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
  5419. +/* message.h  Basic D-Bus message parsing
  5420. + *
  5421. + * Copyright (C) 2010  Collabora Ltd
  5422. + *
  5423. + * This program is free software; you can redistribute it and/or modify
  5424. + * it under the terms of the GNU General Public License as published by
  5425. + * the Free Software Foundation; either version 2 of the License, or
  5426. + * (at your option) any later version.
  5427. + *
  5428. + * This program is distributed in the hope that it will be useful,
  5429. + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  5430. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  5431. + * GNU General Public License for more details.
  5432. + *
  5433. + * You should have received a copy of the GNU General Public License
  5434. + * along with this program; if not, write to the Free Software
  5435. + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  5436. + *
  5437. + */
  5438. +
  5439. +#ifndef DBUS_MESSAGE_H
  5440. +#define DBUS_MESSAGE_H
  5441. +
  5442. +#include <net/af_dbus.h>
  5443. +#include <linux/list.h>
  5444. +
  5445. +/* No need to implement a feature-complete parser. It only implement what is
  5446. + * needed by the bus. */
  5447. +struct DBusMessage {
  5448. +  char *message;
  5449. +  size_t len;
  5450. +  size_t new_len;
  5451. +
  5452. +  /* direct pointers to the fields */
  5453. +  int type;
  5454. +  char *path;
  5455. +  char *interface;
  5456. +  char *member;
  5457. +  char *destination;
  5458. +  char *sender;
  5459. +  char *body_signature;
  5460. +  int body_length;
  5461. +  char *arg0;
  5462. +  char *arg1;
  5463. +  char *arg2;
  5464. +
  5465. +  /* How to add the 'sender' field in the headers */
  5466. +  int new_header_offset;
  5467. +  int len_offset;
  5468. +  int padding_end;
  5469. +};
  5470. +
  5471. +int dbus_message_type_from_string (const char *type_str);
  5472. +
  5473. +const char *dbus_message_type_to_string (int type);
  5474. +
  5475. +int dbus_message_parse(unsigned char *message, size_t len,
  5476. +    struct DBusMessage *dbus_message);
  5477. +
  5478. +int dbus_message_add_sender(struct DBusMessage *dbus_message,
  5479. +    const char *sender, gfp_t gfp_flags);
  5480. +
  5481. +#endif /* DBUS_MESSAGE_H */
  5482. diff --git a/net/dbus/sysctl_net_dbus.c b/net/dbus/sysctl_net_dbus.c
  5483. new file mode 100644
  5484. index 0000000..1f5cd15
  5485. --- /dev/null
  5486. +++ b/net/dbus/sysctl_net_dbus.c
  5487. @@ -0,0 +1,62 @@
  5488. +/*
  5489. + * NET4:       Sysctl interface to net af_dbus subsystem.
  5490. + *
  5491. + * Authors:    Mike Shaver.
  5492. + *
  5493. + *             This program is free software; you can redistribute it and/or
  5494. + *             modify it under the terms of the GNU General Public License
  5495. + *             as published by the Free Software Foundation; either version
  5496. + *             2 of the License, or (at your option) any later version.
  5497. + */
  5498. +
  5499. +#include <linux/mm.h>
  5500. +#include <linux/sysctl.h>
  5501. +
  5502. +#include <net/af_dbus.h>
  5503. +
  5504. +static ctl_table dbus_table[] = {
  5505. +       {
  5506. +               .procname       = "max_dgram_qlen",
  5507. +               .data           = &init_net.unx.sysctl_max_dgram_qlen,
  5508. +               .maxlen         = sizeof(int),
  5509. +               .mode           = 0644,
  5510. +               .proc_handler   = proc_dointvec
  5511. +       },
  5512. +       { }
  5513. +};
  5514. +
  5515. +static struct ctl_path dbus_path[] = {
  5516. +       { .procname = "net", },
  5517. +       { .procname = "dbus", },
  5518. +       { },
  5519. +};
  5520. +
  5521. +int dbus_sysctl_register(struct net *net)
  5522. +{
  5523. +       struct ctl_table *table;
  5524. +
  5525. +       table = kmemdup(dbus_table, sizeof(dbus_table), GFP_KERNEL);
  5526. +       if (table == NULL)
  5527. +               goto err_alloc;
  5528. +
  5529. +       table[0].data = &net->unx.sysctl_max_dgram_qlen;
  5530. +       net->unx.ctl = register_net_sysctl_table(net, dbus_path, table);
  5531. +       if (net->unx.ctl == NULL)
  5532. +               goto err_reg;
  5533. +
  5534. +       return 0;
  5535. +
  5536. +err_reg:
  5537. +       kfree(table);
  5538. +err_alloc:
  5539. +       return -ENOMEM;
  5540. +}
  5541. +
  5542. +void dbus_sysctl_unregister(struct net *net)
  5543. +{
  5544. +       struct ctl_table *table;
  5545. +
  5546. +       table = net->unx.ctl->ctl_table_arg;
  5547. +       unregister_sysctl_table(net->unx.ctl);
  5548. +       kfree(table);
  5549. +}
  5550. diff --git a/security/capability.c b/security/capability.c
  5551. index 8168e3e..377d0b4 100644
  5552. --- a/security/capability.c
  5553. +++ b/security/capability.c
  5554. @@ -554,6 +554,17 @@ static int cap_unix_may_send(struct socket *sock, struct socket *other)
  5555.         return 0;
  5556.  }
  5557.  
  5558. +static int cap_dbus_stream_connect(struct socket *sock, struct socket *other,
  5559. +                                   struct sock *newsk)
  5560. +{
  5561. +        return 0;
  5562. +}
  5563. +
  5564. +static int cap_dbus_may_send(struct socket *sock, struct socket *other)
  5565. +{
  5566. +        return 0;
  5567. +}
  5568. +
  5569.  static int cap_socket_create(int family, int type, int protocol, int kern)
  5570.  {
  5571.         return 0;
  5572. @@ -994,6 +1005,8 @@ void __init security_fixup_ops(struct security_operations *ops)
  5573.  #ifdef CONFIG_SECURITY_NETWORK
  5574.         set_to_cap_if_null(ops, unix_stream_connect);
  5575.         set_to_cap_if_null(ops, unix_may_send);
  5576. +       set_to_cap_if_null(ops, dbus_stream_connect);
  5577. +       set_to_cap_if_null(ops, dbus_may_send);
  5578.         set_to_cap_if_null(ops, socket_create);
  5579.         set_to_cap_if_null(ops, socket_post_create);
  5580.         set_to_cap_if_null(ops, socket_bind);
  5581. diff --git a/security/security.c b/security/security.c
  5582. index 351942a..5516f59 100644
  5583. --- a/security/security.c
  5584. +++ b/security/security.c
  5585. @@ -995,6 +995,19 @@ int security_unix_may_send(struct socket *sock,  struct socket *other)
  5586.  }
  5587.  EXPORT_SYMBOL(security_unix_may_send);
  5588.  
  5589. +int security_dbus_stream_connect(struct socket *sock, struct socket *other,
  5590. +                                 struct sock *newsk)
  5591. +{
  5592. +        return security_ops->dbus_stream_connect(sock, other, newsk);
  5593. +}
  5594. +EXPORT_SYMBOL(security_dbus_stream_connect);
  5595. +
  5596. +int security_dbus_may_send(struct socket *sock,  struct socket *other)
  5597. +{
  5598. +       return security_ops->dbus_may_send(sock, other);
  5599. +}
  5600. +EXPORT_SYMBOL(security_dbus_may_send);
  5601. +
  5602.  int security_socket_create(int family, int type, int protocol, int kern)
  5603.  {
  5604.         return security_ops->socket_create(family, type, protocol, kern);
  5605. diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
  5606. index 5c9f25b..11dfb51 100644
  5607. --- a/security/selinux/hooks.c
  5608. +++ b/security/selinux/hooks.c
  5609. @@ -65,6 +65,7 @@
  5610.  #include <linux/quota.h>
  5611.  #include <linux/un.h>          /* for Unix socket types */
  5612.  #include <net/af_unix.h>       /* for Unix socket types */
  5613. +#include <net/af_dbus.h>       /* for DBus socket types */
  5614.  #include <linux/parser.h>
  5615.  #include <linux/nfs_mount.h>
  5616.  #include <net/ipv6.h>
  5617. @@ -4032,6 +4033,64 @@ static int selinux_socket_unix_may_send(struct socket *sock,
  5618.         return 0;
  5619.  }
  5620.  
  5621. +static int selinux_socket_dbus_stream_connect(struct socket *sock,
  5622. +                                              struct socket *other,
  5623. +                                              struct sock *newsk)
  5624. +{
  5625. +        struct sk_security_struct *ssec;
  5626. +        struct inode_security_struct *isec;
  5627. +        struct inode_security_struct *other_isec;
  5628. +        struct common_audit_data ad;
  5629. +        int err;
  5630. +
  5631. +        isec = SOCK_INODE(sock)->i_security;
  5632. +        other_isec = SOCK_INODE(other)->i_security;
  5633. +
  5634. +        COMMON_AUDIT_DATA_INIT(&ad, NET);
  5635. +        ad.u.net.sk = other->sk;
  5636. +
  5637. +        err = avc_has_perm(isec->sid, other_isec->sid,
  5638. +                           isec->sclass,
  5639. +                           UNIX_STREAM_SOCKET__CONNECTTO, &ad); //FIXME!!!
  5640. +        if (err)
  5641. +                return err;
  5642. +
  5643. +        /* connecting socket */
  5644. +        ssec = sock->sk->sk_security;
  5645. +        ssec->peer_sid = other_isec->sid;
  5646. +
  5647. +        /* server child socket */
  5648. +        ssec = newsk->sk_security;
  5649. +        ssec->peer_sid = isec->sid;
  5650. +        err = security_sid_mls_copy(other_isec->sid, ssec->peer_sid, &ssec->sid)
  5651. +;
  5652. +
  5653. +        return err;
  5654. +}
  5655. +
  5656. +
  5657. +static int selinux_socket_dbus_may_send(struct socket *sock,
  5658. +                                        struct socket *other)
  5659. +{
  5660. +       struct inode_security_struct *isec;
  5661. +       struct inode_security_struct *other_isec;
  5662. +       struct common_audit_data ad;
  5663. +       int err;
  5664. +
  5665. +       isec = SOCK_INODE(sock)->i_security;
  5666. +       other_isec = SOCK_INODE(other)->i_security;
  5667. +
  5668. +       COMMON_AUDIT_DATA_INIT(&ad, NET);
  5669. +       ad.u.net.sk = other->sk;
  5670. +
  5671. +       err = avc_has_perm(isec->sid, other_isec->sid,
  5672. +                          isec->sclass, SOCKET__SENDTO, &ad);
  5673. +       if (err)
  5674. +               return err;
  5675. +
  5676. +       return 0;
  5677. +}
  5678. +
  5679.  static int selinux_inet_sys_rcv_skb(int ifindex, char *addrp, u16 family,
  5680.                                     u32 peer_sid,
  5681.                                     struct common_audit_data *ad)
  5682. @@ -5565,6 +5624,8 @@ static struct security_operations selinux_ops = {
  5683.  
  5684.         .unix_stream_connect =          selinux_socket_unix_stream_connect,
  5685.         .unix_may_send =                selinux_socket_unix_may_send,
  5686. +       .dbus_stream_connect =          selinux_socket_dbus_stream_connect,
  5687. +       .dbus_may_send =                selinux_socket_dbus_may_send,
  5688.  
  5689.         .socket_create =                selinux_socket_create,
  5690.         .socket_post_create =           selinux_socket_post_create,
  5691. --- a/include/net/af_dbus.h
  5692. +++ b/include/net/af_dbus.h
  5693. @@ -58,7 +58,7 @@
  5694.         spinlock_t              lock;
  5695.         unsigned int            gc_candidate : 1;
  5696.         unsigned int            gc_maybe_cycle : 1;
  5697. -       struct socket_wq        peer_wq;
  5698. +       wait_queue_head_t       peer_wait;
  5699.  
  5700.         struct dbus_sock_priv   *priv;
  5701.         unsigned int    daemon_side;
  5702. @@ -72,8 +72,6 @@
  5703.  };
  5704.  #define dbus_sk(__sk) ((struct dbus_sock *)__sk)
  5705.  
  5706. -#define peer_wait peer_wq.wait
  5707. -
  5708.  #ifdef CONFIG_SYSCTL
  5709.  extern int dbus_sysctl_register(struct net *net);
  5710.  extern void dbus_sysctl_unregister(struct net *net);
  5711. --- a/net/dbus/af_dbus.c
  5712. +++ b/net/dbus/af_dbus.c
  5713. @@ -315,16 +315,13 @@
  5714.  
  5715.  static void dbus_write_space(struct sock *sk)
  5716.  {
  5717. -       struct socket_wq *wq;
  5718. -
  5719. -       rcu_read_lock();
  5720. +       read_lock(&sk->sk_callback_lock);
  5721.         if (dbus_writable(sk)) {
  5722. -               wq = rcu_dereference(sk->sk_wq);
  5723. -               if (wq_has_sleeper(wq))
  5724. -                       wake_up_interruptible_sync(&wq->wait);
  5725. +               if (sk_has_sleeper(sk))
  5726. +                       wake_up_interruptible_sync(sk->sk_sleep);
  5727.                 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
  5728.         }
  5729. -       rcu_read_unlock();
  5730. +       read_unlock(&sk->sk_callback_lock);
  5731.  }
  5732.  
  5733.  static void dbus_sock_destructor(struct sock *sk)
  5734. @@ -586,8 +583,7 @@
  5735.         return sk;
  5736.  }
  5737.  
  5738. -static int dbus_create(struct net *net, struct socket *sock, int protocol,
  5739. -                      int kern)
  5740. +static int dbus_create(struct net *net, struct socket *sock, int protocol)
  5741.  {
  5742.         if (protocol && protocol != PF_DBUS)
  5743.                 return -EPROTONOSUPPORT;
  5744. @@ -1007,7 +1003,7 @@
  5745.         current_euid_egid(&newsk->sk_peercred.uid, &newsk->sk_peercred.gid);
  5746.         newu = dbus_sk(newsk);
  5747.         newu->daemon_side       = 1;
  5748. -       newsk->sk_wq            = &newu->peer_wq;
  5749. +       newsk->sk_sleep         = &newu->peer_wait;
  5750.         otheru = dbus_sk(other);
  5751.         newu->bus = otheru->bus;
  5752.         u->bus = otheru->bus;
  5753. @@ -1126,7 +1122,7 @@
  5754.  {
  5755.         struct sock *sk = sock->sk;
  5756.         struct dbus_sock *u;
  5757. -       DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, uaddr);
  5758. +       struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
  5759.         int err = 0;
  5760.  
  5761.         if (peer) {
  5762. @@ -1604,7 +1600,7 @@
  5763.         dbus_state_lock(sk);
  5764.  
  5765.         for (;;) {
  5766. -               prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
  5767. +               prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
  5768.  
  5769.                 if (!skb_queue_empty(&sk->sk_receive_queue) ||
  5770.                     sk->sk_err ||
  5771. @@ -1620,7 +1616,7 @@
  5772.                 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
  5773.         }
  5774.  
  5775. -       finish_wait(sk_sleep(sk), &wait);
  5776. +       finish_wait(sk->sk_sleep, &wait);
  5777.         dbus_state_unlock(sk);
  5778.         return timeo;
  5779.  }
  5780. @@ -1857,7 +1853,7 @@
  5781.         struct sock *sk = sock->sk;
  5782.         unsigned int mask;
  5783.  
  5784. -       sock_poll_wait(file, sk_sleep(sk), wait);
  5785. +       sock_poll_wait(file, sk->sk_sleep, wait);
  5786.         mask = 0;
  5787.  
  5788.         /* exceptional events? */
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!