URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [net/] [khttpd/] [sysctl.c] - Blame information for rev 1774

Go to most recent revision | Details | Compare with Previous | View Log


/*
 
kHTTPd -- the next generation
 
Sysctl interface
 
*/
/****************************************************************
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License as published by
 *      the Free Software Foundation; either version 2, or (at your option)
 *      any later version.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 ****************************************************************/
 
 
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/net.h>
#include <linux/sched.h>
#include <linux/skbuff.h>
#include <linux/smp_lock.h>
#include <linux/sysctl.h>
#include <linux/un.h>
#include <linux/unistd.h>
 
#include <net/ip.h>
#include <net/sock.h>
#include <net/tcp.h>
 
#include <asm/atomic.h>
#include <asm/semaphore.h>
#include <asm/processor.h>
#include <asm/uaccess.h>
 
#include <linux/file.h>
#include "prototypes.h"
 
 
 
char    sysctl_khttpd_docroot[200] = "/var/www";
int     sysctl_khttpd_stop      = 0;
int     sysctl_khttpd_start     = 0;
int     sysctl_khttpd_unload    = 0;
int     sysctl_khttpd_clientport = 80;
int     sysctl_khttpd_permreq    = S_IROTH; /* "other" read-access is required by default*/
int     sysctl_khttpd_permforbid = S_IFDIR | S_ISVTX | S_IXOTH | S_IXGRP | S_IXUSR;
                                /* forbidden is execute, directory and sticky*/
int     sysctl_khttpd_logging   = 0;
int     sysctl_khttpd_serverport= 8080;
 
char    sysctl_khttpd_dynamicstring[200];
int     sysctl_khttpd_sloppymime= 0;
int     sysctl_khttpd_threads   = 2;
int     sysctl_khttpd_maxconnect = 1000;
 
atomic_t        khttpd_stopCount;
 
static struct ctl_table_header *khttpd_table_header;
 
static int sysctl_SecureString(ctl_table *table, int *name, int nlen,
                  void *oldval, size_t *oldlenp,
                  void *newval, size_t newlen, void **context);
static int proc_dosecurestring(ctl_table *table, int write, struct file *filp,
                  void *buffer, size_t *lenp);
static int khttpd_stop_wrap_proc_dointvec(ctl_table *table, int write, struct file *filp,
                  void *buffer, size_t *lenp);
 
 
static ctl_table khttpd_table[] = {
        {       NET_KHTTPD_DOCROOT,
                "documentroot",
                &sysctl_khttpd_docroot,
                sizeof(sysctl_khttpd_docroot),
                0644,
                NULL,
                proc_dostring,
                &sysctl_string,
                NULL,
                NULL,
                NULL
        },
        {       NET_KHTTPD_STOP,
                "stop",
                &sysctl_khttpd_stop,
                sizeof(int),
                0644,
                NULL,
                khttpd_stop_wrap_proc_dointvec,
                &sysctl_intvec,
                NULL,
                NULL,
                NULL
        },
        {       NET_KHTTPD_START,
                "start",
                &sysctl_khttpd_start,
                sizeof(int),
                0644,
                NULL,
                proc_dointvec,
                &sysctl_intvec,
                NULL,
                NULL,
                NULL
        },
        {       NET_KHTTPD_UNLOAD,
                "unload",
                &sysctl_khttpd_unload,
                sizeof(int),
                0644,
                NULL,
                proc_dointvec,
                &sysctl_intvec,
                NULL,
                NULL,
                NULL
        },
        {       NET_KHTTPD_THREADS,
                "threads",
                &sysctl_khttpd_threads,
                sizeof(int),
                0644,
                NULL,
                proc_dointvec,
                &sysctl_intvec,
                NULL,
                NULL,
                NULL
        },
        {       NET_KHTTPD_MAXCONNECT,
                "maxconnect",
                &sysctl_khttpd_maxconnect,
                sizeof(int),
                0644,
                NULL,
                proc_dointvec,
                &sysctl_intvec,
                NULL,
                NULL,
                NULL
        },
        {       NET_KHTTPD_SLOPPYMIME,
                "sloppymime",
                &sysctl_khttpd_sloppymime,
                sizeof(int),
                0644,
                NULL,
                proc_dointvec,
                &sysctl_intvec,
                NULL,
                NULL,
                NULL
        },
        {       NET_KHTTPD_CLIENTPORT,
                "clientport",
                &sysctl_khttpd_clientport,
                sizeof(int),
                0644,
                NULL,
                proc_dointvec,
                &sysctl_intvec,
                NULL,
                NULL,
                NULL
        },
        {       NET_KHTTPD_PERMREQ,
                "perm_required",
                &sysctl_khttpd_permreq,
                sizeof(int),
                0644,
                NULL,
                proc_dointvec,
                &sysctl_intvec,
                NULL,
                NULL,
                NULL
        },
        {       NET_KHTTPD_PERMFORBID,
                "perm_forbid",
                &sysctl_khttpd_permforbid,
                sizeof(int),
                0644,
                NULL,
                proc_dointvec,
                &sysctl_intvec,
                NULL,
                NULL,
                NULL
        },
        {       NET_KHTTPD_LOGGING,
                "logging",
                &sysctl_khttpd_logging,
                sizeof(int),
                0644,
                NULL,
                proc_dointvec,
                &sysctl_intvec,
                NULL,
                NULL,
                NULL
        },
        {       NET_KHTTPD_SERVERPORT,
                "serverport",
                &sysctl_khttpd_serverport,
                sizeof(int),
                0644,
                NULL,
                proc_dointvec,
                &sysctl_intvec,
                NULL,
                NULL,
                NULL
        },
        {       NET_KHTTPD_DYNAMICSTRING,
                "dynamic",
                &sysctl_khttpd_dynamicstring,
                sizeof(sysctl_khttpd_dynamicstring),
                0644,
                NULL,
                proc_dosecurestring,
                &sysctl_SecureString,
                NULL,
                NULL,
                NULL
        },
        {0,0,0,0,0,0,0,0,0,0,0}    };
 
 
static ctl_table khttpd_dir_table[] = {
        {NET_KHTTPD, "khttpd", NULL, 0, 0555, khttpd_table,0,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,0,0}
};
 
static ctl_table khttpd_root_table[] = {
        {CTL_NET, "net", NULL, 0, 0555, khttpd_dir_table,0,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,0,0}
};
 
 
void StartSysctl(void)
{
        khttpd_table_header = register_sysctl_table(khttpd_root_table,1);
}
 
 
void EndSysctl(void)
{
        unregister_sysctl_table(khttpd_table_header);
}
 
static int proc_dosecurestring(ctl_table *table, int write, struct file *filp,
                  void *buffer, size_t *lenp)
{
        size_t len;
        char *p, c=0;
        char String[256];
 
        if ((table->data==0) || (table->maxlen==0) || (*lenp==0) ||
            ((filp->f_pos!=0) && (write==0))) {
                *lenp = 0;
                return 0;
        }
 
        if (write!=0) {
                len = 0;
                p = buffer;
                while (len < *lenp) {
                        if(get_user(c, p++))
                                return -EFAULT;
                        if (c == 0 || c == '\n')
                                break;
                        len++;
                }
                if (len >= table->maxlen)
                        len = table->maxlen-1;
                if(copy_from_user(String, buffer,(unsigned long)len))
                        return -EFAULT;
                ((char *) String)[len] = 0;
                filp->f_pos += *lenp;
                AddDynamicString(String);
        } else {
                GetSecureString(String);
                len = strlen(String);
                if (len > table->maxlen)
                        len = table->maxlen;
                if (len > *lenp)
                        len = *lenp;
                if (len!=0)
                        if(copy_to_user(buffer, String,(unsigned long)len))
                                return -EFAULT;
                if (len < *lenp) {
                        if(put_user('\n', ((char *) buffer) + len))
                                return -EFAULT;
                        len++;
                }
                *lenp = len;
                filp->f_pos += len;
        }
        return 0;
}
 
/* A wrapper around proc_dointvec that computes
 * khttpd_stopCount = # of times sysctl_khttpd_stop has gone true
 * Sensing sysctl_khttpd_stop in other threads is racy;
 * sensing khttpd_stopCount in other threads is not.
 */
static int khttpd_stop_wrap_proc_dointvec(ctl_table *table, int write, struct file *filp,
                  void *buffer, size_t *lenp)
{
        int rv;
        int oldstop = sysctl_khttpd_stop;
        rv = proc_dointvec(table, write, filp, buffer, lenp);
        if (sysctl_khttpd_stop && !oldstop)
                atomic_inc(&khttpd_stopCount);
 
        return rv;
}
 
 
static int sysctl_SecureString (/*@unused@*/ctl_table *table,
                                /*@unused@*/int *name,
                                /*@unused@*/int nlen,
                                /*@unused@*/void *oldval,
                                /*@unused@*/size_t *oldlenp,
                                /*@unused@*/void *newval,
                                /*@unused@*/size_t newlen,
                                /*@unused@*/void **context)
{
        return -ENOSYS;
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [net/] [khttpd/] [sysctl.c] - Blame information for rev 1774

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2
3			`kHTTPd -- the next generation`
4
5			`Sysctl interface`
6
7			`*/`
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, or (at your option)`
12			`* any later version.`
13			`*`
14			`* This program is distributed in the hope that it will be useful,`
15			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
16			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
17			`* GNU General Public License for more details.`
18			`*`
19			`* You should have received a copy of the GNU General Public License`
20			`* along with this program; if not, write to the Free Software`
21			`* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.`
22			`*`
23			`****************************************************************/`
24
25
26			`#include <linux/kernel.h>`
27			`#include <linux/errno.h>`
28			`#include <linux/slab.h>`
29			`#include <linux/net.h>`
30			`#include <linux/sched.h>`
31			`#include <linux/skbuff.h>`
32			`#include <linux/smp_lock.h>`
33			`#include <linux/sysctl.h>`
34			`#include <linux/un.h>`
35			`#include <linux/unistd.h>`
36
37			`#include <net/ip.h>`
38			`#include <net/sock.h>`
39			`#include <net/tcp.h>`
40
41			`#include <asm/atomic.h>`
42			`#include <asm/semaphore.h>`
43			`#include <asm/processor.h>`
44			`#include <asm/uaccess.h>`
45
46			`#include <linux/file.h>`
47			`#include "prototypes.h"`
48
49
50
51			`char sysctl_khttpd_docroot[200] = "/var/www";`
52			`int sysctl_khttpd_stop = 0;`
53			`int sysctl_khttpd_start = 0;`
54			`int sysctl_khttpd_unload = 0;`
55			`int sysctl_khttpd_clientport = 80;`
56			`int sysctl_khttpd_permreq = S_IROTH; /* "other" read-access is required by default*/`
57			`int sysctl_khttpd_permforbid = S_IFDIR \| S_ISVTX \| S_IXOTH \| S_IXGRP \| S_IXUSR;`
58			`/* forbidden is execute, directory and sticky*/`
59			`int sysctl_khttpd_logging = 0;`
60			`int sysctl_khttpd_serverport= 8080;`
61
62			`char sysctl_khttpd_dynamicstring[200];`
63			`int sysctl_khttpd_sloppymime= 0;`
64			`int sysctl_khttpd_threads = 2;`
65			`int sysctl_khttpd_maxconnect = 1000;`
66
67			`atomic_t khttpd_stopCount;`
68
69			`static struct ctl_table_header *khttpd_table_header;`
70
71			`static int sysctl_SecureString(ctl_table table, int name, int nlen,`
72			`void oldval, size_t oldlenp,`
73			`void newval, size_t newlen, void *context);`
74			`static int proc_dosecurestring(ctl_table table, int write, struct file filp,`
75			`void buffer, size_t lenp);`
76			`static int khttpd_stop_wrap_proc_dointvec(ctl_table table, int write, struct file filp,`
77			`void buffer, size_t lenp);`
78
79
80			`static ctl_table khttpd_table[] = {`
81			`{ NET_KHTTPD_DOCROOT,`
82			`"documentroot",`
83			`&sysctl_khttpd_docroot,`
84			`sizeof(sysctl_khttpd_docroot),`
85			`0644,`
86			`NULL,`
87			`proc_dostring,`
88			`&sysctl_string,`
89			`NULL,`
90			`NULL,`
91			`NULL`
92			`},`
93			`{ NET_KHTTPD_STOP,`
94			`"stop",`
95			`&sysctl_khttpd_stop,`
96			`sizeof(int),`
97			`0644,`
98			`NULL,`
99			`khttpd_stop_wrap_proc_dointvec,`
100			`&sysctl_intvec,`
101			`NULL,`
102			`NULL,`
103			`NULL`
104			`},`
105			`{ NET_KHTTPD_START,`
106			`"start",`
107			`&sysctl_khttpd_start,`
108			`sizeof(int),`
109			`0644,`
110			`NULL,`
111			`proc_dointvec,`
112			`&sysctl_intvec,`
113			`NULL,`
114			`NULL,`
115			`NULL`
116			`},`
117			`{ NET_KHTTPD_UNLOAD,`
118			`"unload",`
119			`&sysctl_khttpd_unload,`
120			`sizeof(int),`
121			`0644,`
122			`NULL,`
123			`proc_dointvec,`
124			`&sysctl_intvec,`
125			`NULL,`
126			`NULL,`
127			`NULL`
128			`},`
129			`{ NET_KHTTPD_THREADS,`
130			`"threads",`
131			`&sysctl_khttpd_threads,`
132			`sizeof(int),`
133			`0644,`
134			`NULL,`
135			`proc_dointvec,`
136			`&sysctl_intvec,`
137			`NULL,`
138			`NULL,`
139			`NULL`
140			`},`
141			`{ NET_KHTTPD_MAXCONNECT,`
142			`"maxconnect",`
143			`&sysctl_khttpd_maxconnect,`
144			`sizeof(int),`
145			`0644,`
146			`NULL,`
147			`proc_dointvec,`
148			`&sysctl_intvec,`
149			`NULL,`
150			`NULL,`
151			`NULL`
152			`},`
153			`{ NET_KHTTPD_SLOPPYMIME,`
154			`"sloppymime",`
155			`&sysctl_khttpd_sloppymime,`
156			`sizeof(int),`
157			`0644,`
158			`NULL,`
159			`proc_dointvec,`
160			`&sysctl_intvec,`
161			`NULL,`
162			`NULL,`
163			`NULL`
164			`},`
165			`{ NET_KHTTPD_CLIENTPORT,`
166			`"clientport",`
167			`&sysctl_khttpd_clientport,`
168			`sizeof(int),`
169			`0644,`
170			`NULL,`
171			`proc_dointvec,`
172			`&sysctl_intvec,`
173			`NULL,`
174			`NULL,`
175			`NULL`
176			`},`
177			`{ NET_KHTTPD_PERMREQ,`
178			`"perm_required",`
179			`&sysctl_khttpd_permreq,`
180			`sizeof(int),`
181			`0644,`
182			`NULL,`
183			`proc_dointvec,`
184			`&sysctl_intvec,`
185			`NULL,`
186			`NULL,`
187			`NULL`
188			`},`
189			`{ NET_KHTTPD_PERMFORBID,`
190			`"perm_forbid",`
191			`&sysctl_khttpd_permforbid,`
192			`sizeof(int),`
193			`0644,`
194			`NULL,`
195			`proc_dointvec,`
196			`&sysctl_intvec,`
197			`NULL,`
198			`NULL,`
199			`NULL`
200			`},`
201			`{ NET_KHTTPD_LOGGING,`
202			`"logging",`
203			`&sysctl_khttpd_logging,`
204			`sizeof(int),`
205			`0644,`
206			`NULL,`
207			`proc_dointvec,`
208			`&sysctl_intvec,`
209			`NULL,`
210			`NULL,`
211			`NULL`
212			`},`
213			`{ NET_KHTTPD_SERVERPORT,`
214			`"serverport",`
215			`&sysctl_khttpd_serverport,`
216			`sizeof(int),`
217			`0644,`
218			`NULL,`
219			`proc_dointvec,`
220			`&sysctl_intvec,`
221			`NULL,`
222			`NULL,`
223			`NULL`
224			`},`
225			`{ NET_KHTTPD_DYNAMICSTRING,`
226			`"dynamic",`
227			`&sysctl_khttpd_dynamicstring,`
228			`sizeof(sysctl_khttpd_dynamicstring),`
229			`0644,`
230			`NULL,`
231			`proc_dosecurestring,`
232			`&sysctl_SecureString,`
233			`NULL,`
234			`NULL,`
235			`NULL`
236			`},`
237			`{0,0,0,0,0,0,0,0,0,0,0} };`
238
239
240			`static ctl_table khttpd_dir_table[] = {`
241			`{NET_KHTTPD, "khttpd", NULL, 0, 0555, khttpd_table,0,0,0,0,0},`
242			`{0,0,0,0,0,0,0,0,0,0,0}`
243			`};`
244
245			`static ctl_table khttpd_root_table[] = {`
246			`{CTL_NET, "net", NULL, 0, 0555, khttpd_dir_table,0,0,0,0,0},`
247			`{0,0,0,0,0,0,0,0,0,0,0}`
248			`};`
249
250
251			`void StartSysctl(void)`
252			`{`
253			`khttpd_table_header = register_sysctl_table(khttpd_root_table,1);`
254			`}`
255
256
257			`void EndSysctl(void)`
258			`{`
259			`unregister_sysctl_table(khttpd_table_header);`
260			`}`
261
262			`static int proc_dosecurestring(ctl_table table, int write, struct file filp,`
263			`void buffer, size_t lenp)`
264			`{`
265			`size_t len;`
266			`char *p, c=0;`
267			`char String[256];`
268
269			`if ((table->data==0) \|\| (table->maxlen==0) \|\| (*lenp==0) \|\|`
270			`((filp->f_pos!=0) && (write==0))) {`
271			`*lenp = 0;`
272			`return 0;`
273			`}`
274
275			`if (write!=0) {`
276			`len = 0;`
277			`p = buffer;`
278			`while (len < *lenp) {`
279			`if(get_user(c, p++))`
280			`return -EFAULT;`
281			`if (c == 0 \|\| c == '\n')`
282			`break;`
283			`len++;`
284			`}`
285			`if (len >= table->maxlen)`
286			`len = table->maxlen-1;`
287			`if(copy_from_user(String, buffer,(unsigned long)len))`
288			`return -EFAULT;`
289			`((char *) String)[len] = 0;`
290			`filp->f_pos += *lenp;`
291			`AddDynamicString(String);`
292			`} else {`
293			`GetSecureString(String);`
294			`len = strlen(String);`
295			`if (len > table->maxlen)`
296			`len = table->maxlen;`
297			`if (len > *lenp)`
298			`len = *lenp;`
299			`if (len!=0)`
300			`if(copy_to_user(buffer, String,(unsigned long)len))`
301			`return -EFAULT;`
302			`if (len < *lenp) {`
303			`if(put_user('\n', ((char *) buffer) + len))`
304			`return -EFAULT;`
305			`len++;`
306			`}`
307			`*lenp = len;`
308			`filp->f_pos += len;`
309			`}`
310			`return 0;`
311			`}`
312
313			`/* A wrapper around proc_dointvec that computes`
314			`* khttpd_stopCount = # of times sysctl_khttpd_stop has gone true`
315			`* Sensing sysctl_khttpd_stop in other threads is racy;`
316			`* sensing khttpd_stopCount in other threads is not.`
317			`*/`
318			`static int khttpd_stop_wrap_proc_dointvec(ctl_table table, int write, struct file filp,`
319			`void buffer, size_t lenp)`
320			`{`
321			`int rv;`
322			`int oldstop = sysctl_khttpd_stop;`
323			`rv = proc_dointvec(table, write, filp, buffer, lenp);`
324			`if (sysctl_khttpd_stop && !oldstop)`
325			`atomic_inc(&khttpd_stopCount);`
326
327			`return rv;`
328			`}`
329
330
331			`static int sysctl_SecureString (/@unused@/ctl_table *table,`
332			`/@unused@/int *name,`
333			`/@unused@/int nlen,`
334			`/@unused@/void *oldval,`
335			`/@unused@/size_t *oldlenp,`
336			`/@unused@/void *newval,`
337			`/@unused@/size_t newlen,`
338			`/@unused@/void **context)`
339			`{`
340			`return -ENOSYS;`
341			`}`