blob: 58d4dd1af5c7054f76d1d26e7b407eaaed12a25a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Stub functions for the default security function pointers in case no
3 * security model is loaded.
4 *
5 * Copyright (C) 2001 WireX Communications, Inc <chris@wirex.com>
6 * Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com>
7 * Copyright (C) 2001 Networks Associates Technology, Inc <ssmalley@nai.com>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 */
14
15#undef DEBUG
16
Randy.Dunlapc59ede72006-01-11 12:17:46 -080017#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/kernel.h>
19#include <linux/mman.h>
20#include <linux/pagemap.h>
21#include <linux/swap.h>
22#include <linux/security.h>
23#include <linux/skbuff.h>
24#include <linux/netlink.h>
25#include <net/sock.h>
26#include <linux/xattr.h>
27#include <linux/hugetlb.h>
28#include <linux/ptrace.h>
29#include <linux/file.h>
30
31static int dummy_ptrace (struct task_struct *parent, struct task_struct *child)
32{
33 return 0;
34}
35
36static int dummy_capget (struct task_struct *target, kernel_cap_t * effective,
37 kernel_cap_t * inheritable, kernel_cap_t * permitted)
38{
Andrew Morgan72c2d582007-10-18 03:05:59 -070039 if (target->euid == 0) {
Andrew Morgane338d262008-02-04 22:29:42 -080040 cap_set_full(*permitted);
41 cap_set_init_eff(*effective);
42 } else {
43 cap_clear(*permitted);
44 cap_clear(*effective);
Andrew Morgan72c2d582007-10-18 03:05:59 -070045 }
Andrew Morgane338d262008-02-04 22:29:42 -080046
47 cap_clear(*inheritable);
48
49 if (target->fsuid != 0) {
50 *permitted = cap_drop_fs_set(*permitted);
51 *effective = cap_drop_fs_set(*effective);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 }
53 return 0;
54}
55
56static int dummy_capset_check (struct task_struct *target,
57 kernel_cap_t * effective,
58 kernel_cap_t * inheritable,
59 kernel_cap_t * permitted)
60{
61 return -EPERM;
62}
63
64static void dummy_capset_set (struct task_struct *target,
65 kernel_cap_t * effective,
66 kernel_cap_t * inheritable,
67 kernel_cap_t * permitted)
68{
69 return;
70}
71
72static int dummy_acct (struct file *file)
73{
74 return 0;
75}
76
77static int dummy_capable (struct task_struct *tsk, int cap)
78{
79 if (cap_raised (tsk->cap_effective, cap))
80 return 0;
81 return -EPERM;
82}
83
84static int dummy_sysctl (ctl_table * table, int op)
85{
86 return 0;
87}
88
89static int dummy_quotactl (int cmds, int type, int id, struct super_block *sb)
90{
91 return 0;
92}
93
94static int dummy_quota_on (struct dentry *dentry)
95{
96 return 0;
97}
98
99static int dummy_syslog (int type)
100{
101 if ((type != 3 && type != 10) && current->euid)
102 return -EPERM;
103 return 0;
104}
105
106static int dummy_settime(struct timespec *ts, struct timezone *tz)
107{
108 if (!capable(CAP_SYS_TIME))
109 return -EPERM;
110 return 0;
111}
112
Alan Cox34b4e4a2007-08-22 14:01:28 -0700113static int dummy_vm_enough_memory(struct mm_struct *mm, long pages)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114{
115 int cap_sys_admin = 0;
116
117 if (dummy_capable(current, CAP_SYS_ADMIN) == 0)
118 cap_sys_admin = 1;
Alan Cox34b4e4a2007-08-22 14:01:28 -0700119 return __vm_enough_memory(mm, pages, cap_sys_admin);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120}
121
122static int dummy_bprm_alloc_security (struct linux_binprm *bprm)
123{
124 return 0;
125}
126
127static void dummy_bprm_free_security (struct linux_binprm *bprm)
128{
129 return;
130}
131
132static void dummy_bprm_apply_creds (struct linux_binprm *bprm, int unsafe)
133{
134 if (bprm->e_uid != current->uid || bprm->e_gid != current->gid) {
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700135 set_dumpable(current->mm, suid_dumpable);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
137 if ((unsafe & ~LSM_UNSAFE_PTRACE_CAP) && !capable(CAP_SETUID)) {
138 bprm->e_uid = current->uid;
139 bprm->e_gid = current->gid;
140 }
141 }
142
143 current->suid = current->euid = current->fsuid = bprm->e_uid;
144 current->sgid = current->egid = current->fsgid = bprm->e_gid;
145
146 dummy_capget(current, &current->cap_effective, &current->cap_inheritable, &current->cap_permitted);
147}
148
149static void dummy_bprm_post_apply_creds (struct linux_binprm *bprm)
150{
151 return;
152}
153
154static int dummy_bprm_set_security (struct linux_binprm *bprm)
155{
156 return 0;
157}
158
159static int dummy_bprm_check_security (struct linux_binprm *bprm)
160{
161 return 0;
162}
163
164static int dummy_bprm_secureexec (struct linux_binprm *bprm)
165{
166 /* The new userland will simply use the value provided
167 in the AT_SECURE field to decide whether secure mode
168 is required. Hence, this logic is required to preserve
169 the legacy decision algorithm used by the old userland. */
170 return (current->euid != current->uid ||
171 current->egid != current->gid);
172}
173
174static int dummy_sb_alloc_security (struct super_block *sb)
175{
176 return 0;
177}
178
179static void dummy_sb_free_security (struct super_block *sb)
180{
181 return;
182}
183
Eric Parise0007522008-03-05 10:31:54 -0500184static int dummy_sb_copy_data (char *orig, char *copy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185{
186 return 0;
187}
188
189static int dummy_sb_kern_mount (struct super_block *sb, void *data)
190{
191 return 0;
192}
193
David Howells726c3342006-06-23 02:02:58 -0700194static int dummy_sb_statfs (struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195{
196 return 0;
197}
198
Al Virob5266eb2008-03-22 17:48:24 -0400199static int dummy_sb_mount (char *dev_name, struct path *path, char *type,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 unsigned long flags, void *data)
201{
202 return 0;
203}
204
Al Virob5266eb2008-03-22 17:48:24 -0400205static int dummy_sb_check_sb (struct vfsmount *mnt, struct path *path)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206{
207 return 0;
208}
209
210static int dummy_sb_umount (struct vfsmount *mnt, int flags)
211{
212 return 0;
213}
214
215static void dummy_sb_umount_close (struct vfsmount *mnt)
216{
217 return;
218}
219
220static void dummy_sb_umount_busy (struct vfsmount *mnt)
221{
222 return;
223}
224
225static void dummy_sb_post_remount (struct vfsmount *mnt, unsigned long flags,
226 void *data)
227{
228 return;
229}
230
231
Al Virob5266eb2008-03-22 17:48:24 -0400232static void dummy_sb_post_addmount (struct vfsmount *mnt, struct path *path)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233{
234 return;
235}
236
Al Virob5266eb2008-03-22 17:48:24 -0400237static int dummy_sb_pivotroot (struct path *old_path, struct path *new_path)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238{
239 return 0;
240}
241
Al Virob5266eb2008-03-22 17:48:24 -0400242static void dummy_sb_post_pivotroot (struct path *old_path, struct path *new_path)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243{
244 return;
245}
246
Eric Parise0007522008-03-05 10:31:54 -0500247static int dummy_sb_get_mnt_opts(const struct super_block *sb,
248 struct security_mnt_opts *opts)
Eric Parisc9180a52007-11-30 13:00:35 -0500249{
Eric Parise0007522008-03-05 10:31:54 -0500250 security_init_mnt_opts(opts);
Eric Parisc9180a52007-11-30 13:00:35 -0500251 return 0;
252}
253
Eric Parise0007522008-03-05 10:31:54 -0500254static int dummy_sb_set_mnt_opts(struct super_block *sb,
255 struct security_mnt_opts *opts)
Eric Parisc9180a52007-11-30 13:00:35 -0500256{
Eric Parise0007522008-03-05 10:31:54 -0500257 if (unlikely(opts->num_mnt_opts))
Eric Parisc9180a52007-11-30 13:00:35 -0500258 return -EOPNOTSUPP;
259 return 0;
260}
261
262static void dummy_sb_clone_mnt_opts(const struct super_block *oldsb,
263 struct super_block *newsb)
264{
265 return;
266}
267
Eric Parise0007522008-03-05 10:31:54 -0500268static int dummy_sb_parse_opts_str(char *options, struct security_mnt_opts *opts)
269{
270 return 0;
271}
272
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273static int dummy_inode_alloc_security (struct inode *inode)
274{
275 return 0;
276}
277
278static void dummy_inode_free_security (struct inode *inode)
279{
280 return;
281}
282
Stephen Smalley5e41ff92005-09-09 13:01:35 -0700283static int dummy_inode_init_security (struct inode *inode, struct inode *dir,
284 char **name, void **value, size_t *len)
285{
286 return -EOPNOTSUPP;
287}
288
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289static int dummy_inode_create (struct inode *inode, struct dentry *dentry,
290 int mask)
291{
292 return 0;
293}
294
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295static int dummy_inode_link (struct dentry *old_dentry, struct inode *inode,
296 struct dentry *new_dentry)
297{
298 return 0;
299}
300
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301static int dummy_inode_unlink (struct inode *inode, struct dentry *dentry)
302{
303 return 0;
304}
305
306static int dummy_inode_symlink (struct inode *inode, struct dentry *dentry,
307 const char *name)
308{
309 return 0;
310}
311
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312static int dummy_inode_mkdir (struct inode *inode, struct dentry *dentry,
313 int mask)
314{
315 return 0;
316}
317
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318static int dummy_inode_rmdir (struct inode *inode, struct dentry *dentry)
319{
320 return 0;
321}
322
323static int dummy_inode_mknod (struct inode *inode, struct dentry *dentry,
324 int mode, dev_t dev)
325{
326 return 0;
327}
328
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329static int dummy_inode_rename (struct inode *old_inode,
330 struct dentry *old_dentry,
331 struct inode *new_inode,
332 struct dentry *new_dentry)
333{
334 return 0;
335}
336
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337static int dummy_inode_readlink (struct dentry *dentry)
338{
339 return 0;
340}
341
342static int dummy_inode_follow_link (struct dentry *dentry,
343 struct nameidata *nameidata)
344{
345 return 0;
346}
347
348static int dummy_inode_permission (struct inode *inode, int mask, struct nameidata *nd)
349{
350 return 0;
351}
352
353static int dummy_inode_setattr (struct dentry *dentry, struct iattr *iattr)
354{
355 return 0;
356}
357
358static int dummy_inode_getattr (struct vfsmount *mnt, struct dentry *dentry)
359{
360 return 0;
361}
362
363static void dummy_inode_delete (struct inode *ino)
364{
365 return;
366}
367
368static int dummy_inode_setxattr (struct dentry *dentry, char *name, void *value,
369 size_t size, int flags)
370{
371 if (!strncmp(name, XATTR_SECURITY_PREFIX,
372 sizeof(XATTR_SECURITY_PREFIX) - 1) &&
373 !capable(CAP_SYS_ADMIN))
374 return -EPERM;
375 return 0;
376}
377
378static void dummy_inode_post_setxattr (struct dentry *dentry, char *name, void *value,
379 size_t size, int flags)
380{
381}
382
383static int dummy_inode_getxattr (struct dentry *dentry, char *name)
384{
385 return 0;
386}
387
388static int dummy_inode_listxattr (struct dentry *dentry)
389{
390 return 0;
391}
392
393static int dummy_inode_removexattr (struct dentry *dentry, char *name)
394{
395 if (!strncmp(name, XATTR_SECURITY_PREFIX,
396 sizeof(XATTR_SECURITY_PREFIX) - 1) &&
397 !capable(CAP_SYS_ADMIN))
398 return -EPERM;
399 return 0;
400}
401
Serge E. Hallynb5376772007-10-16 23:31:36 -0700402static int dummy_inode_need_killpriv(struct dentry *dentry)
403{
404 return 0;
405}
406
407static int dummy_inode_killpriv(struct dentry *dentry)
408{
409 return 0;
410}
411
David P. Quigley42492592008-02-04 22:29:39 -0800412static int dummy_inode_getsecurity(const struct inode *inode, const char *name, void **buffer, bool alloc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413{
414 return -EOPNOTSUPP;
415}
416
417static int dummy_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags)
418{
419 return -EOPNOTSUPP;
420}
421
422static int dummy_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size)
423{
424 return 0;
425}
426
Ahmed S. Darwish8a076192008-03-01 21:51:09 +0200427static void dummy_inode_getsecid(const struct inode *inode, u32 *secid)
428{
429 *secid = 0;
430}
431
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432static int dummy_file_permission (struct file *file, int mask)
433{
434 return 0;
435}
436
437static int dummy_file_alloc_security (struct file *file)
438{
439 return 0;
440}
441
442static void dummy_file_free_security (struct file *file)
443{
444 return;
445}
446
447static int dummy_file_ioctl (struct file *file, unsigned int command,
448 unsigned long arg)
449{
450 return 0;
451}
452
453static int dummy_file_mmap (struct file *file, unsigned long reqprot,
454 unsigned long prot,
Eric Parised032182007-06-28 15:55:21 -0400455 unsigned long flags,
456 unsigned long addr,
457 unsigned long addr_only)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458{
Eric Parisab5a91a2007-11-26 18:47:46 -0500459 if ((addr < mmap_min_addr) && !capable(CAP_SYS_RAWIO))
Eric Parised032182007-06-28 15:55:21 -0400460 return -EACCES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 return 0;
462}
463
464static int dummy_file_mprotect (struct vm_area_struct *vma,
465 unsigned long reqprot,
466 unsigned long prot)
467{
468 return 0;
469}
470
471static int dummy_file_lock (struct file *file, unsigned int cmd)
472{
473 return 0;
474}
475
476static int dummy_file_fcntl (struct file *file, unsigned int cmd,
477 unsigned long arg)
478{
479 return 0;
480}
481
482static int dummy_file_set_fowner (struct file *file)
483{
484 return 0;
485}
486
487static int dummy_file_send_sigiotask (struct task_struct *tsk,
488 struct fown_struct *fown, int sig)
489{
490 return 0;
491}
492
493static int dummy_file_receive (struct file *file)
494{
495 return 0;
496}
497
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +0900498static int dummy_dentry_open (struct file *file)
499{
500 return 0;
501}
502
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503static int dummy_task_create (unsigned long clone_flags)
504{
505 return 0;
506}
507
508static int dummy_task_alloc_security (struct task_struct *p)
509{
510 return 0;
511}
512
513static void dummy_task_free_security (struct task_struct *p)
514{
515 return;
516}
517
518static int dummy_task_setuid (uid_t id0, uid_t id1, uid_t id2, int flags)
519{
520 return 0;
521}
522
523static int dummy_task_post_setuid (uid_t id0, uid_t id1, uid_t id2, int flags)
524{
525 dummy_capget(current, &current->cap_effective, &current->cap_inheritable, &current->cap_permitted);
526 return 0;
527}
528
529static int dummy_task_setgid (gid_t id0, gid_t id1, gid_t id2, int flags)
530{
531 return 0;
532}
533
534static int dummy_task_setpgid (struct task_struct *p, pid_t pgid)
535{
536 return 0;
537}
538
539static int dummy_task_getpgid (struct task_struct *p)
540{
541 return 0;
542}
543
544static int dummy_task_getsid (struct task_struct *p)
545{
546 return 0;
547}
548
David Quigleyf9008e42006-06-30 01:55:46 -0700549static void dummy_task_getsecid (struct task_struct *p, u32 *secid)
Ahmed S. Darwish8a076192008-03-01 21:51:09 +0200550{
551 *secid = 0;
552}
David Quigleyf9008e42006-06-30 01:55:46 -0700553
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554static int dummy_task_setgroups (struct group_info *group_info)
555{
556 return 0;
557}
558
559static int dummy_task_setnice (struct task_struct *p, int nice)
560{
561 return 0;
562}
563
James Morris03e68062006-06-23 02:03:58 -0700564static int dummy_task_setioprio (struct task_struct *p, int ioprio)
565{
566 return 0;
567}
568
David Quigleya1836a42006-06-30 01:55:49 -0700569static int dummy_task_getioprio (struct task_struct *p)
570{
571 return 0;
572}
573
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574static int dummy_task_setrlimit (unsigned int resource, struct rlimit *new_rlim)
575{
576 return 0;
577}
578
579static int dummy_task_setscheduler (struct task_struct *p, int policy,
580 struct sched_param *lp)
581{
582 return 0;
583}
584
585static int dummy_task_getscheduler (struct task_struct *p)
586{
587 return 0;
588}
589
David Quigley35601542006-06-23 02:04:01 -0700590static int dummy_task_movememory (struct task_struct *p)
591{
592 return 0;
593}
594
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595static int dummy_task_wait (struct task_struct *p)
596{
597 return 0;
598}
599
600static int dummy_task_kill (struct task_struct *p, struct siginfo *info,
David Quigleyf9008e42006-06-30 01:55:46 -0700601 int sig, u32 secid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602{
603 return 0;
604}
605
606static int dummy_task_prctl (int option, unsigned long arg2, unsigned long arg3,
Andrew G. Morgan3898b1b2008-04-28 02:13:40 -0700607 unsigned long arg4, unsigned long arg5, long *rc_p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608{
609 return 0;
610}
611
612static void dummy_task_reparent_to_init (struct task_struct *p)
613{
614 p->euid = p->fsuid = 0;
615 return;
616}
617
618static void dummy_task_to_inode(struct task_struct *p, struct inode *inode)
619{ }
620
621static int dummy_ipc_permission (struct kern_ipc_perm *ipcp, short flag)
622{
623 return 0;
624}
625
Ahmed S. Darwish8a076192008-03-01 21:51:09 +0200626static void dummy_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid)
627{
628 *secid = 0;
629}
630
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631static int dummy_msg_msg_alloc_security (struct msg_msg *msg)
632{
633 return 0;
634}
635
636static void dummy_msg_msg_free_security (struct msg_msg *msg)
637{
638 return;
639}
640
641static int dummy_msg_queue_alloc_security (struct msg_queue *msq)
642{
643 return 0;
644}
645
646static void dummy_msg_queue_free_security (struct msg_queue *msq)
647{
648 return;
649}
650
651static int dummy_msg_queue_associate (struct msg_queue *msq,
652 int msqflg)
653{
654 return 0;
655}
656
657static int dummy_msg_queue_msgctl (struct msg_queue *msq, int cmd)
658{
659 return 0;
660}
661
662static int dummy_msg_queue_msgsnd (struct msg_queue *msq, struct msg_msg *msg,
663 int msgflg)
664{
665 return 0;
666}
667
668static int dummy_msg_queue_msgrcv (struct msg_queue *msq, struct msg_msg *msg,
669 struct task_struct *target, long type,
670 int mode)
671{
672 return 0;
673}
674
675static int dummy_shm_alloc_security (struct shmid_kernel *shp)
676{
677 return 0;
678}
679
680static void dummy_shm_free_security (struct shmid_kernel *shp)
681{
682 return;
683}
684
685static int dummy_shm_associate (struct shmid_kernel *shp, int shmflg)
686{
687 return 0;
688}
689
690static int dummy_shm_shmctl (struct shmid_kernel *shp, int cmd)
691{
692 return 0;
693}
694
695static int dummy_shm_shmat (struct shmid_kernel *shp, char __user *shmaddr,
696 int shmflg)
697{
698 return 0;
699}
700
701static int dummy_sem_alloc_security (struct sem_array *sma)
702{
703 return 0;
704}
705
706static void dummy_sem_free_security (struct sem_array *sma)
707{
708 return;
709}
710
711static int dummy_sem_associate (struct sem_array *sma, int semflg)
712{
713 return 0;
714}
715
716static int dummy_sem_semctl (struct sem_array *sma, int cmd)
717{
718 return 0;
719}
720
721static int dummy_sem_semop (struct sem_array *sma,
722 struct sembuf *sops, unsigned nsops, int alter)
723{
724 return 0;
725}
726
727static int dummy_netlink_send (struct sock *sk, struct sk_buff *skb)
728{
729 NETLINK_CB(skb).eff_cap = current->cap_effective;
730 return 0;
731}
732
Darrel Goeddelc7bdb542006-06-27 13:26:11 -0700733static int dummy_netlink_recv (struct sk_buff *skb, int cap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734{
Darrel Goeddelc7bdb542006-06-27 13:26:11 -0700735 if (!cap_raised (NETLINK_CB (skb).eff_cap, cap))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 return -EPERM;
737 return 0;
738}
739
740#ifdef CONFIG_SECURITY_NETWORK
741static int dummy_unix_stream_connect (struct socket *sock,
742 struct socket *other,
743 struct sock *newsk)
744{
745 return 0;
746}
747
748static int dummy_unix_may_send (struct socket *sock,
749 struct socket *other)
750{
751 return 0;
752}
753
754static int dummy_socket_create (int family, int type,
755 int protocol, int kern)
756{
757 return 0;
758}
759
Venkat Yekkirala7420ed22006-08-04 23:17:57 -0700760static int dummy_socket_post_create (struct socket *sock, int family, int type,
761 int protocol, int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762{
Venkat Yekkirala7420ed22006-08-04 23:17:57 -0700763 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764}
765
766static int dummy_socket_bind (struct socket *sock, struct sockaddr *address,
767 int addrlen)
768{
769 return 0;
770}
771
772static int dummy_socket_connect (struct socket *sock, struct sockaddr *address,
773 int addrlen)
774{
775 return 0;
776}
777
778static int dummy_socket_listen (struct socket *sock, int backlog)
779{
780 return 0;
781}
782
783static int dummy_socket_accept (struct socket *sock, struct socket *newsock)
784{
785 return 0;
786}
787
788static void dummy_socket_post_accept (struct socket *sock,
789 struct socket *newsock)
790{
791 return;
792}
793
794static int dummy_socket_sendmsg (struct socket *sock, struct msghdr *msg,
795 int size)
796{
797 return 0;
798}
799
800static int dummy_socket_recvmsg (struct socket *sock, struct msghdr *msg,
801 int size, int flags)
802{
803 return 0;
804}
805
806static int dummy_socket_getsockname (struct socket *sock)
807{
808 return 0;
809}
810
811static int dummy_socket_getpeername (struct socket *sock)
812{
813 return 0;
814}
815
816static int dummy_socket_setsockopt (struct socket *sock, int level, int optname)
817{
818 return 0;
819}
820
821static int dummy_socket_getsockopt (struct socket *sock, int level, int optname)
822{
823 return 0;
824}
825
826static int dummy_socket_shutdown (struct socket *sock, int how)
827{
828 return 0;
829}
830
831static int dummy_socket_sock_rcv_skb (struct sock *sk, struct sk_buff *skb)
832{
833 return 0;
834}
835
Catherine Zhang2c7946a2006-03-20 22:41:23 -0800836static int dummy_socket_getpeersec_stream(struct socket *sock, char __user *optval,
837 int __user *optlen, unsigned len)
838{
839 return -ENOPROTOOPT;
840}
841
Catherine Zhangdc49c1f2006-08-02 14:12:06 -0700842static int dummy_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843{
844 return -ENOPROTOOPT;
845}
846
Al Viro7d877f32005-10-21 03:20:43 -0400847static inline int dummy_sk_alloc_security (struct sock *sk, int family, gfp_t priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848{
849 return 0;
850}
851
852static inline void dummy_sk_free_security (struct sock *sk)
853{
854}
Trent Jaegerdf718372005-12-13 23:12:27 -0800855
Venkat Yekkirala892c1412006-08-04 23:08:56 -0700856static inline void dummy_sk_clone_security (const struct sock *sk, struct sock *newsk)
857{
858}
859
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700860static inline void dummy_sk_getsecid(struct sock *sk, u32 *secid)
Trent Jaegerdf718372005-12-13 23:12:27 -0800861{
Trent Jaegerdf718372005-12-13 23:12:27 -0800862}
Venkat Yekkirala4237c752006-07-24 23:32:50 -0700863
864static inline void dummy_sock_graft(struct sock* sk, struct socket *parent)
865{
866}
867
868static inline int dummy_inet_conn_request(struct sock *sk,
869 struct sk_buff *skb, struct request_sock *req)
870{
871 return 0;
872}
873
874static inline void dummy_inet_csk_clone(struct sock *newsk,
875 const struct request_sock *req)
876{
877}
878
Venkat Yekkirala6b877692006-11-08 17:04:09 -0600879static inline void dummy_inet_conn_established(struct sock *sk,
880 struct sk_buff *skb)
881{
882}
883
Venkat Yekkirala4237c752006-07-24 23:32:50 -0700884static inline void dummy_req_classify_flow(const struct request_sock *req,
885 struct flowi *fl)
886{
887}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888#endif /* CONFIG_SECURITY_NETWORK */
889
Trent Jaegerdf718372005-12-13 23:12:27 -0800890#ifdef CONFIG_SECURITY_NETWORK_XFRM
Paul Moore03e1ad72008-04-12 19:07:52 -0700891static int dummy_xfrm_policy_alloc_security(struct xfrm_sec_ctx **ctxp,
892 struct xfrm_user_sec_ctx *sec_ctx)
Trent Jaegerdf718372005-12-13 23:12:27 -0800893{
894 return 0;
895}
896
Paul Moore03e1ad72008-04-12 19:07:52 -0700897static inline int dummy_xfrm_policy_clone_security(struct xfrm_sec_ctx *old_ctx,
898 struct xfrm_sec_ctx **new_ctxp)
Trent Jaegerdf718372005-12-13 23:12:27 -0800899{
900 return 0;
901}
902
Paul Moore03e1ad72008-04-12 19:07:52 -0700903static void dummy_xfrm_policy_free_security(struct xfrm_sec_ctx *ctx)
Trent Jaegerdf718372005-12-13 23:12:27 -0800904{
905}
906
Paul Moore03e1ad72008-04-12 19:07:52 -0700907static int dummy_xfrm_policy_delete_security(struct xfrm_sec_ctx *ctx)
Catherine Zhangc8c05a82006-06-08 23:39:49 -0700908{
909 return 0;
910}
911
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -0700912static int dummy_xfrm_state_alloc_security(struct xfrm_state *x,
Venkat Yekkiralac1a856c2006-11-08 17:03:44 -0600913 struct xfrm_user_sec_ctx *sec_ctx, u32 secid)
Trent Jaegerdf718372005-12-13 23:12:27 -0800914{
915 return 0;
916}
917
918static void dummy_xfrm_state_free_security(struct xfrm_state *x)
919{
920}
921
Catherine Zhangc8c05a82006-06-08 23:39:49 -0700922static int dummy_xfrm_state_delete_security(struct xfrm_state *x)
923{
924 return 0;
925}
926
Paul Moore03e1ad72008-04-12 19:07:52 -0700927static int dummy_xfrm_policy_lookup(struct xfrm_sec_ctx *ctx,
928 u32 sk_sid, u8 dir)
Trent Jaegerdf718372005-12-13 23:12:27 -0800929{
930 return 0;
931}
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -0700932
933static int dummy_xfrm_state_pol_flow_match(struct xfrm_state *x,
934 struct xfrm_policy *xp, struct flowi *fl)
935{
936 return 1;
937}
938
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700939static int dummy_xfrm_decode_session(struct sk_buff *skb, u32 *fl, int ckall)
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -0700940{
941 return 0;
942}
943
Trent Jaegerdf718372005-12-13 23:12:27 -0800944#endif /* CONFIG_SECURITY_NETWORK_XFRM */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945static int dummy_register_security (const char *name, struct security_operations *ops)
946{
947 return -EINVAL;
948}
949
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950static void dummy_d_instantiate (struct dentry *dentry, struct inode *inode)
951{
952 return;
953}
954
Al Viro04ff9702007-03-12 16:17:58 +0000955static int dummy_getprocattr(struct task_struct *p, char *name, char **value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956{
957 return -EINVAL;
958}
959
960static int dummy_setprocattr(struct task_struct *p, char *name, void *value, size_t size)
961{
962 return -EINVAL;
963}
964
Catherine Zhangdc49c1f2006-08-02 14:12:06 -0700965static int dummy_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
966{
967 return -EOPNOTSUPP;
968}
969
David Howells63cb3442008-01-15 23:47:35 +0000970static int dummy_secctx_to_secid(char *secdata, u32 seclen, u32 *secid)
971{
972 return -EOPNOTSUPP;
973}
974
Catherine Zhangdc49c1f2006-08-02 14:12:06 -0700975static void dummy_release_secctx(char *secdata, u32 seclen)
976{
977}
978
David Howells29db9192005-10-30 15:02:44 -0800979#ifdef CONFIG_KEYS
David Howells7e047ef2006-06-26 00:24:50 -0700980static inline int dummy_key_alloc(struct key *key, struct task_struct *ctx,
981 unsigned long flags)
David Howells29db9192005-10-30 15:02:44 -0800982{
983 return 0;
984}
985
986static inline void dummy_key_free(struct key *key)
987{
988}
989
990static inline int dummy_key_permission(key_ref_t key_ref,
991 struct task_struct *context,
992 key_perm_t perm)
993{
994 return 0;
995}
996#endif /* CONFIG_KEYS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997
Ahmed S. Darwish03d37d22008-03-01 22:00:05 +0200998#ifdef CONFIG_AUDIT
999static inline int dummy_audit_rule_init(u32 field, u32 op, char *rulestr,
1000 void **lsmrule)
1001{
1002 return 0;
1003}
1004
1005static inline int dummy_audit_rule_known(struct audit_krule *krule)
1006{
1007 return 0;
1008}
1009
1010static inline int dummy_audit_rule_match(u32 secid, u32 field, u32 op,
1011 void *lsmrule,
1012 struct audit_context *actx)
1013{
1014 return 0;
1015}
1016
1017static inline void dummy_audit_rule_free(void *lsmrule)
1018{ }
1019
1020#endif /* CONFIG_AUDIT */
1021
Ahmed S. Darwish076c54c2008-03-06 18:09:10 +02001022struct security_operations dummy_security_ops = {
1023 .name = "dummy",
1024};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025
1026#define set_to_dummy_if_null(ops, function) \
1027 do { \
1028 if (!ops->function) { \
1029 ops->function = dummy_##function; \
1030 pr_debug("Had to override the " #function \
1031 " security operation with the dummy one.\n");\
1032 } \
1033 } while (0)
1034
1035void security_fixup_ops (struct security_operations *ops)
1036{
1037 set_to_dummy_if_null(ops, ptrace);
1038 set_to_dummy_if_null(ops, capget);
1039 set_to_dummy_if_null(ops, capset_check);
1040 set_to_dummy_if_null(ops, capset_set);
1041 set_to_dummy_if_null(ops, acct);
1042 set_to_dummy_if_null(ops, capable);
1043 set_to_dummy_if_null(ops, quotactl);
1044 set_to_dummy_if_null(ops, quota_on);
1045 set_to_dummy_if_null(ops, sysctl);
1046 set_to_dummy_if_null(ops, syslog);
1047 set_to_dummy_if_null(ops, settime);
1048 set_to_dummy_if_null(ops, vm_enough_memory);
1049 set_to_dummy_if_null(ops, bprm_alloc_security);
1050 set_to_dummy_if_null(ops, bprm_free_security);
1051 set_to_dummy_if_null(ops, bprm_apply_creds);
1052 set_to_dummy_if_null(ops, bprm_post_apply_creds);
1053 set_to_dummy_if_null(ops, bprm_set_security);
1054 set_to_dummy_if_null(ops, bprm_check_security);
1055 set_to_dummy_if_null(ops, bprm_secureexec);
1056 set_to_dummy_if_null(ops, sb_alloc_security);
1057 set_to_dummy_if_null(ops, sb_free_security);
1058 set_to_dummy_if_null(ops, sb_copy_data);
1059 set_to_dummy_if_null(ops, sb_kern_mount);
1060 set_to_dummy_if_null(ops, sb_statfs);
1061 set_to_dummy_if_null(ops, sb_mount);
1062 set_to_dummy_if_null(ops, sb_check_sb);
1063 set_to_dummy_if_null(ops, sb_umount);
1064 set_to_dummy_if_null(ops, sb_umount_close);
1065 set_to_dummy_if_null(ops, sb_umount_busy);
1066 set_to_dummy_if_null(ops, sb_post_remount);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 set_to_dummy_if_null(ops, sb_post_addmount);
1068 set_to_dummy_if_null(ops, sb_pivotroot);
1069 set_to_dummy_if_null(ops, sb_post_pivotroot);
Eric Parisc9180a52007-11-30 13:00:35 -05001070 set_to_dummy_if_null(ops, sb_get_mnt_opts);
1071 set_to_dummy_if_null(ops, sb_set_mnt_opts);
1072 set_to_dummy_if_null(ops, sb_clone_mnt_opts);
Eric Parise0007522008-03-05 10:31:54 -05001073 set_to_dummy_if_null(ops, sb_parse_opts_str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 set_to_dummy_if_null(ops, inode_alloc_security);
1075 set_to_dummy_if_null(ops, inode_free_security);
Stephen Smalley5e41ff92005-09-09 13:01:35 -07001076 set_to_dummy_if_null(ops, inode_init_security);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 set_to_dummy_if_null(ops, inode_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 set_to_dummy_if_null(ops, inode_link);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 set_to_dummy_if_null(ops, inode_unlink);
1080 set_to_dummy_if_null(ops, inode_symlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 set_to_dummy_if_null(ops, inode_mkdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 set_to_dummy_if_null(ops, inode_rmdir);
1083 set_to_dummy_if_null(ops, inode_mknod);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 set_to_dummy_if_null(ops, inode_rename);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 set_to_dummy_if_null(ops, inode_readlink);
1086 set_to_dummy_if_null(ops, inode_follow_link);
1087 set_to_dummy_if_null(ops, inode_permission);
1088 set_to_dummy_if_null(ops, inode_setattr);
1089 set_to_dummy_if_null(ops, inode_getattr);
1090 set_to_dummy_if_null(ops, inode_delete);
1091 set_to_dummy_if_null(ops, inode_setxattr);
1092 set_to_dummy_if_null(ops, inode_post_setxattr);
1093 set_to_dummy_if_null(ops, inode_getxattr);
1094 set_to_dummy_if_null(ops, inode_listxattr);
1095 set_to_dummy_if_null(ops, inode_removexattr);
Serge E. Hallynb5376772007-10-16 23:31:36 -07001096 set_to_dummy_if_null(ops, inode_need_killpriv);
1097 set_to_dummy_if_null(ops, inode_killpriv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 set_to_dummy_if_null(ops, inode_getsecurity);
1099 set_to_dummy_if_null(ops, inode_setsecurity);
1100 set_to_dummy_if_null(ops, inode_listsecurity);
Ahmed S. Darwish8a076192008-03-01 21:51:09 +02001101 set_to_dummy_if_null(ops, inode_getsecid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 set_to_dummy_if_null(ops, file_permission);
1103 set_to_dummy_if_null(ops, file_alloc_security);
1104 set_to_dummy_if_null(ops, file_free_security);
1105 set_to_dummy_if_null(ops, file_ioctl);
1106 set_to_dummy_if_null(ops, file_mmap);
1107 set_to_dummy_if_null(ops, file_mprotect);
1108 set_to_dummy_if_null(ops, file_lock);
1109 set_to_dummy_if_null(ops, file_fcntl);
1110 set_to_dummy_if_null(ops, file_set_fowner);
1111 set_to_dummy_if_null(ops, file_send_sigiotask);
1112 set_to_dummy_if_null(ops, file_receive);
Yuichi Nakamura788e7dd2007-09-14 09:27:07 +09001113 set_to_dummy_if_null(ops, dentry_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 set_to_dummy_if_null(ops, task_create);
1115 set_to_dummy_if_null(ops, task_alloc_security);
1116 set_to_dummy_if_null(ops, task_free_security);
1117 set_to_dummy_if_null(ops, task_setuid);
1118 set_to_dummy_if_null(ops, task_post_setuid);
1119 set_to_dummy_if_null(ops, task_setgid);
1120 set_to_dummy_if_null(ops, task_setpgid);
1121 set_to_dummy_if_null(ops, task_getpgid);
1122 set_to_dummy_if_null(ops, task_getsid);
David Quigleyf9008e42006-06-30 01:55:46 -07001123 set_to_dummy_if_null(ops, task_getsecid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 set_to_dummy_if_null(ops, task_setgroups);
1125 set_to_dummy_if_null(ops, task_setnice);
James Morris03e68062006-06-23 02:03:58 -07001126 set_to_dummy_if_null(ops, task_setioprio);
David Quigleya1836a42006-06-30 01:55:49 -07001127 set_to_dummy_if_null(ops, task_getioprio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 set_to_dummy_if_null(ops, task_setrlimit);
1129 set_to_dummy_if_null(ops, task_setscheduler);
1130 set_to_dummy_if_null(ops, task_getscheduler);
David Quigley35601542006-06-23 02:04:01 -07001131 set_to_dummy_if_null(ops, task_movememory);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 set_to_dummy_if_null(ops, task_wait);
1133 set_to_dummy_if_null(ops, task_kill);
1134 set_to_dummy_if_null(ops, task_prctl);
1135 set_to_dummy_if_null(ops, task_reparent_to_init);
1136 set_to_dummy_if_null(ops, task_to_inode);
1137 set_to_dummy_if_null(ops, ipc_permission);
Ahmed S. Darwish8a076192008-03-01 21:51:09 +02001138 set_to_dummy_if_null(ops, ipc_getsecid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 set_to_dummy_if_null(ops, msg_msg_alloc_security);
1140 set_to_dummy_if_null(ops, msg_msg_free_security);
1141 set_to_dummy_if_null(ops, msg_queue_alloc_security);
1142 set_to_dummy_if_null(ops, msg_queue_free_security);
1143 set_to_dummy_if_null(ops, msg_queue_associate);
1144 set_to_dummy_if_null(ops, msg_queue_msgctl);
1145 set_to_dummy_if_null(ops, msg_queue_msgsnd);
1146 set_to_dummy_if_null(ops, msg_queue_msgrcv);
1147 set_to_dummy_if_null(ops, shm_alloc_security);
1148 set_to_dummy_if_null(ops, shm_free_security);
1149 set_to_dummy_if_null(ops, shm_associate);
1150 set_to_dummy_if_null(ops, shm_shmctl);
1151 set_to_dummy_if_null(ops, shm_shmat);
1152 set_to_dummy_if_null(ops, sem_alloc_security);
1153 set_to_dummy_if_null(ops, sem_free_security);
1154 set_to_dummy_if_null(ops, sem_associate);
1155 set_to_dummy_if_null(ops, sem_semctl);
1156 set_to_dummy_if_null(ops, sem_semop);
1157 set_to_dummy_if_null(ops, netlink_send);
1158 set_to_dummy_if_null(ops, netlink_recv);
1159 set_to_dummy_if_null(ops, register_security);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 set_to_dummy_if_null(ops, d_instantiate);
1161 set_to_dummy_if_null(ops, getprocattr);
1162 set_to_dummy_if_null(ops, setprocattr);
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07001163 set_to_dummy_if_null(ops, secid_to_secctx);
David Howells63cb3442008-01-15 23:47:35 +00001164 set_to_dummy_if_null(ops, secctx_to_secid);
Catherine Zhangdc49c1f2006-08-02 14:12:06 -07001165 set_to_dummy_if_null(ops, release_secctx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166#ifdef CONFIG_SECURITY_NETWORK
1167 set_to_dummy_if_null(ops, unix_stream_connect);
1168 set_to_dummy_if_null(ops, unix_may_send);
1169 set_to_dummy_if_null(ops, socket_create);
1170 set_to_dummy_if_null(ops, socket_post_create);
1171 set_to_dummy_if_null(ops, socket_bind);
1172 set_to_dummy_if_null(ops, socket_connect);
1173 set_to_dummy_if_null(ops, socket_listen);
1174 set_to_dummy_if_null(ops, socket_accept);
1175 set_to_dummy_if_null(ops, socket_post_accept);
1176 set_to_dummy_if_null(ops, socket_sendmsg);
1177 set_to_dummy_if_null(ops, socket_recvmsg);
1178 set_to_dummy_if_null(ops, socket_getsockname);
1179 set_to_dummy_if_null(ops, socket_getpeername);
1180 set_to_dummy_if_null(ops, socket_setsockopt);
1181 set_to_dummy_if_null(ops, socket_getsockopt);
1182 set_to_dummy_if_null(ops, socket_shutdown);
1183 set_to_dummy_if_null(ops, socket_sock_rcv_skb);
Arnaldo Carvalho de Meloc841aa02006-03-20 22:47:37 -08001184 set_to_dummy_if_null(ops, socket_getpeersec_stream);
1185 set_to_dummy_if_null(ops, socket_getpeersec_dgram);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 set_to_dummy_if_null(ops, sk_alloc_security);
1187 set_to_dummy_if_null(ops, sk_free_security);
Venkat Yekkirala892c1412006-08-04 23:08:56 -07001188 set_to_dummy_if_null(ops, sk_clone_security);
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -07001189 set_to_dummy_if_null(ops, sk_getsecid);
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001190 set_to_dummy_if_null(ops, sock_graft);
1191 set_to_dummy_if_null(ops, inet_conn_request);
1192 set_to_dummy_if_null(ops, inet_csk_clone);
Venkat Yekkirala6b877692006-11-08 17:04:09 -06001193 set_to_dummy_if_null(ops, inet_conn_established);
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001194 set_to_dummy_if_null(ops, req_classify_flow);
Trent Jaegerdf718372005-12-13 23:12:27 -08001195 #endif /* CONFIG_SECURITY_NETWORK */
1196#ifdef CONFIG_SECURITY_NETWORK_XFRM
1197 set_to_dummy_if_null(ops, xfrm_policy_alloc_security);
1198 set_to_dummy_if_null(ops, xfrm_policy_clone_security);
1199 set_to_dummy_if_null(ops, xfrm_policy_free_security);
Catherine Zhangc8c05a82006-06-08 23:39:49 -07001200 set_to_dummy_if_null(ops, xfrm_policy_delete_security);
Trent Jaegerdf718372005-12-13 23:12:27 -08001201 set_to_dummy_if_null(ops, xfrm_state_alloc_security);
1202 set_to_dummy_if_null(ops, xfrm_state_free_security);
Catherine Zhangc8c05a82006-06-08 23:39:49 -07001203 set_to_dummy_if_null(ops, xfrm_state_delete_security);
Trent Jaegerdf718372005-12-13 23:12:27 -08001204 set_to_dummy_if_null(ops, xfrm_policy_lookup);
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -07001205 set_to_dummy_if_null(ops, xfrm_state_pol_flow_match);
Venkat Yekkiralae0d1caa2006-07-24 23:29:07 -07001206 set_to_dummy_if_null(ops, xfrm_decode_session);
Trent Jaegerdf718372005-12-13 23:12:27 -08001207#endif /* CONFIG_SECURITY_NETWORK_XFRM */
David Howells29db9192005-10-30 15:02:44 -08001208#ifdef CONFIG_KEYS
1209 set_to_dummy_if_null(ops, key_alloc);
1210 set_to_dummy_if_null(ops, key_free);
1211 set_to_dummy_if_null(ops, key_permission);
1212#endif /* CONFIG_KEYS */
Ahmed S. Darwish03d37d22008-03-01 22:00:05 +02001213#ifdef CONFIG_AUDIT
1214 set_to_dummy_if_null(ops, audit_rule_init);
1215 set_to_dummy_if_null(ops, audit_rule_known);
1216 set_to_dummy_if_null(ops, audit_rule_match);
1217 set_to_dummy_if_null(ops, audit_rule_free);
1218#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219}
1220