static int __init init(void)
{
int i, ret;
/* If no port given, default to standard irc port */
if (ports[0] == 0)
ports[0] = 500;
for (i = 0; (i < MAX_PORTS) && ports[i]; i++) {
memset(&ipsec_helpers[i], 0,
sizeof(struct ip_conntrack_helper));
ipsec_helpers[i].tuple.src.u.udp.port = htons(ports[i]);
ipsec_helpers[i].tuple.dst.protonum = IPPROTO_UDP;
ipsec_helpers[i].mask.src.u.udp.port = 0xFFFF;
ipsec_helpers[i].mask.dst.protonum = 0xFFFF;
ipsec_helpers[i].help = help;
ret = ip_conntrack_helper_register(&ipsec_helpers[i]);
if (ret) {
printk("ip_conntrack_ipsec: ERROR registering port %d\n",
ports[i]);
fini();
return -EBUSY;
}
ports_n_c++;
}
return 0;
}
static int __init init(void)
{
int i, ret;
if (ports[0] == 0)
ports[0] = WMINITIAL;
for (i = 0; (i < MAXWM_PORTS) && ports[i]; i++) {
memset(&wm[i], 0, sizeof(struct ip_conntrack_helper));
wm[i].tuple.src.u.tcp.port = htons(ports[i]);
wm[i].tuple.dst.protonum = IPPROTO_TCP;
wm[i].mask.src.u.tcp.port = 0xFFFF;
/*eshi*/
wm[i].mask.dst.protonum = 0xFFFF;
wm[i].max_expected = WMMAXEXPECTED;
wm[i].timeout = 0;
wm[i].flags = IP_CT_HELPER_F_REUSE_EXPECT;
wm[i].me = ip_conntrack_wm;
wm[i].help = help;
DEBUGP("ip_conntrack_wm: registering helper for port %d\n",
ports[i]);
ret = ip_conntrack_helper_register(&wm[i]);
if (ret) {
fini();
printk("ip_conntrack_wm: registering helper for port FAILED \n");
return ret;
}
ports_c++;
}
return 0;
}
static int __init init(void)
{
int port, ret;
char *tmpname;
/* If no port given, default to standard RPC port */
if (ports[0] == 0)
ports[0] = RPC_PORT;
for (port = 0; (port < MAX_PORTS) && ports[port]; port++) {
memset(&rpc_helpers[port], 0, sizeof(struct ip_conntrack_helper));
tmpname = &rpc_names[port][0];
if (ports[port] == RPC_PORT)
sprintf(tmpname, "rpc");
else
sprintf(tmpname, "rpc-%d", ports[port]);
rpc_helpers[port].name = tmpname;
rpc_helpers[port].me = THIS_MODULE;
rpc_helpers[port].max_expected = 1;
rpc_helpers[port].timeout = 5 * 60; /* stes */
rpc_helpers[port].tuple.dst.protonum = IPPROTO_UDP;
rpc_helpers[port].mask.dst.protonum = 0xff;
/* RPC can come from ports 0:65535 to ports[port] (111) */
rpc_helpers[port].tuple.src.u.udp.port = htons(ports[port]);
rpc_helpers[port].mask.src.u.udp.port = htons(0xffff);
rpc_helpers[port].mask.dst.u.udp.port = htons(0x0);
rpc_helpers[port].help = help;
PRINTK("registering helper for port #%d: %d/UDP\n", port, ports[port]);
PRINTK("helper match ip %u.%u.%u.%u:%u->%u.%u.%u.%u:%u\n",
NIPQUAD(rpc_helpers[port].tuple.dst.ip),
ntohs(rpc_helpers[port].tuple.dst.u.udp.port),
NIPQUAD(rpc_helpers[port].tuple.src.ip),
ntohs(rpc_helpers[port].tuple.src.u.udp.port));
PRINTK("helper match mask %u.%u.%u.%u:%u->%u.%u.%u.%u:%u\n",
NIPQUAD(rpc_helpers[port].mask.dst.ip),
ntohs(rpc_helpers[port].mask.dst.u.udp.port),
NIPQUAD(rpc_helpers[port].mask.src.ip),
ntohs(rpc_helpers[port].mask.src.u.udp.port));
ret = ip_conntrack_helper_register(&rpc_helpers[port]);
if (ret) {
printk("ERROR registering port %d\n",
ports[port]);
fini();
return -EBUSY;
}
ports_n_c++;
}
return 0;
}
static int __init init(void)
{
int err;
DEBUGP("PPTP netfilter connection tracking: ");
if((err = ip_conntrack_helper_register(&pptp_out)))
printk("register failed!\n");
else
DEBUGP("registered\n");
pptp_proc_create();
return err;
}
/* ip_conntrack_pptp initialization */
static int __init init(void)
{
int retcode;
DEBUGP(__FILE__ ": registering helper\n");
if ((retcode = ip_conntrack_helper_register(&pptp))) {
printk(KERN_ERR "Unable to register conntrack application "
"helper for pptp: %d\n", retcode);
return -EIO;
}
printk("ip_conntrack_pptp version %s loaded\n", IP_CT_PPTP_VERSION);
return 0;
}
static int __init init(void)
{
int ret;
amanda_buffer = kmalloc(65536, GFP_KERNEL);
if (!amanda_buffer)
return -ENOMEM;
ret = ip_conntrack_helper_register(&amanda_helper);
if (ret < 0) {
kfree(amanda_buffer);
return ret;
}
return 0;
}
static int __init init(void)
{
int i, ret;
char *tmpname;
if (!ports[0])
ports[0]=TFTP_PORT;
for (i = 0 ; (i < MAX_PORTS) && ports[i] ; i++) {
/* Create helper structure */
memset(&tftp[i], 0, sizeof(struct ip_conntrack_helper));
tftp[i].tuple.dst.protonum = IPPROTO_UDP;
tftp[i].tuple.src.u.udp.port = htons(ports[i]);
tftp[i].mask.dst.protonum = 0xFFFF;
tftp[i].mask.src.u.udp.port = 0xFFFF;
tftp[i].max_expected = 1;
tftp[i].timeout = 0;
tftp[i].flags = IP_CT_HELPER_F_REUSE_EXPECT;
tftp[i].me = THIS_MODULE;
tftp[i].help = tftp_help;
tmpname = &tftp_names[i][0];
if (ports[i] == TFTP_PORT)
sprintf(tmpname, "tftp");
else
sprintf(tmpname, "tftp-%d", i);
tftp[i].name = tmpname;
DEBUGP("port #%d: %d\n", i, ports[i]);
ret=ip_conntrack_helper_register(&tftp[i]);
if (ret) {
printk("ERROR registering helper for port %d\n",
ports[i]);
fini();
return(ret);
}
ports_c++;
}
return(0);
}
static int __init init(void)
{
int i, ret;
char *tmpname;
if(!ports[0])
ports[0]=QUAKE3_MASTER_PORT;
for(i = 0 ; (i < MAX_PORTS) && ports[i] ; i++) {
/* Create helper structure */
memset(&quake3[i], 0, sizeof(struct ip_conntrack_helper));
quake3[i].tuple.dst.protonum = IPPROTO_UDP;
quake3[i].tuple.src.u.udp.port = htons(ports[i]);
quake3[i].mask.dst.protonum = 0xFF;
quake3[i].mask.src.u.udp.port = 0xFFFF;
quake3[i].help = quake3_help;
quake3[i].me = THIS_MODULE;
quake3[i].timeout = 120;
tmpname = &quake3_names[i][0];
if (ports[i] == QUAKE3_MASTER_PORT)
sprintf(tmpname, "quake3");
else
sprintf(tmpname, "quake3-%d", i);
quake3[i].name = tmpname;
DEBUGP("ip_conntrack_quake3: registering helper for port %d\n",
ports[i]);
ret=ip_conntrack_helper_register(&quake3[i]);
if(ret) {
fini();
return(ret);
}
ports_c++;
}
return(0);
}
static int __init
init(void)
{
int i, ret;
char *tmpname;
if (!ports[0])
ports[0] = IPSEC_UDP_PORT;
for (i = 0 ; (i < MAX_PORTS) && ports[i] ; i++) {
/* Create helper structure */
ipsec[i].tuple.dst.protonum = IPPROTO_UDP;
ipsec[i].tuple.src.u.udp.port = htons(ports[i]);
ipsec[i].mask.dst.protonum = 0xFFFF;
ipsec[i].mask.src.u.udp.port = 0xFFFF;
ipsec[i].max_expected = 1;
ipsec[i].timeout = 0;
//ipsec[i].flags = IP_CT_HELPER_F_REUSE_EXPECT;
ipsec[i].me = THIS_MODULE;
ipsec[i].help = ipsec_help;
tmpname = &ipsec_names[i][0];
if (ports[i] == IPSEC_UDP_PORT)
sprintf(tmpname, "ipsec");
else
sprintf(tmpname, "ipsec-%d", i);
ipsec[i].name = tmpname;
//printk( KERN_DEBUG "%s:%sport #%d: %d\n", __FILE__,
// __FUNCTION__, i, ports[i]);
ret=ip_conntrack_helper_register(&ipsec[i]);
if (ret) {
//printk("ERROR registering helper for port %d\n", ports[i]);
fini();
return(ret);
}
ports_c++;
}
return(0);
}
static int __init ip_conntrack_tftp_init(void)
{
int i, ret;
char *tmpname;
if (ports_c == 0)
ports[ports_c++] = TFTP_PORT;
for (i = 0; i < ports_c; i++) {
/* Create helper structure */
memset(&tftp[i], 0, sizeof(struct ip_conntrack_helper));
tftp[i].tuple.dst.protonum = IPPROTO_UDP;
tftp[i].tuple.src.u.udp.port = htons(ports[i]);
tftp[i].mask.dst.protonum = 0xFF;
tftp[i].mask.src.u.udp.port = 0xFFFF;
tftp[i].max_expected = 1;
tftp[i].timeout = 5 * 60; /* 5 minutes */
tftp[i].me = THIS_MODULE;
tftp[i].help = tftp_help;
tmpname = &tftp_names[i][0];
if (ports[i] == TFTP_PORT)
sprintf(tmpname, "tftp");
else
sprintf(tmpname, "tftp-%d", i);
tftp[i].name = tmpname;
DEBUGP("port #%d: %d\n", i, ports[i]);
ret=ip_conntrack_helper_register(&tftp[i]);
if (ret) {
printk("ERROR registering helper for port %d\n",
ports[i]);
ip_conntrack_tftp_fini();
return(ret);
}
}
return(0);
}
static int __init ip_conntrack_amanda_init(void)
{
int ret, i;
ret = -ENOMEM;
for (i = 0; i < ARRAY_SIZE(search); i++) {
search[i].ts = textsearch_prepare(ts_algo, search[i].string,
search[i].len,
GFP_KERNEL, TS_AUTOLOAD);
if (search[i].ts == NULL)
goto err;
}
ret = ip_conntrack_helper_register(&amanda_helper);
if (ret < 0)
goto err;
return 0;
err:
for (; i >= 0; i--) {
if (search[i].ts)
textsearch_destroy(search[i].ts);
}
return ret;
}
static int __init
init(void)
{
int i, ret;
struct ip_conntrack_helper *hlpr;
char *tmpname;
printk("ip_conntrack_rtsp v" IP_NF_RTSP_VERSION " loading\n");
if (max_outstanding < 1)
{
printk("ip_conntrack_rtsp: max_outstanding must be a positive integer\n");
return -EBUSY;
}
if (setup_timeout < 0)
{
printk("ip_conntrack_rtsp: setup_timeout must be a positive integer\n");
return -EBUSY;
}
/* If no port given, default to standard rtsp port */
if (ports[0] == 0)
{
ports[0] = RTSP_PORT;
}
for (i = 0; (i < MAX_PORTS) && ports[i]; i++)
{
hlpr = &rtsp_helpers[i];
memset(hlpr, 0, sizeof(struct ip_conntrack_helper));
hlpr->tuple.src.u.tcp.port = htons(ports[i]);
hlpr->tuple.dst.protonum = IPPROTO_TCP;
hlpr->mask.src.u.tcp.port = 0xFFFF;
hlpr->mask.dst.protonum = 0xFF;
hlpr->max_expected = max_outstanding;
hlpr->timeout = setup_timeout;
hlpr->me = THIS_MODULE;
hlpr->help = help;
tmpname = &rtsp_names[i][0];
if (ports[i] == RTSP_PORT)
{
sprintf(tmpname, "rtsp");
}
else
{
sprintf(tmpname, "rtsp-%d", i);
}
hlpr->name = tmpname;
DEBUGP("port #%d: %d\n", i, ports[i]);
ret = ip_conntrack_helper_register(hlpr);
if (ret)
{
printk("ip_conntrack_rtsp: ERROR registering port %d\n", ports[i]);
fini();
return -EBUSY;
}
num_ports++;
}
return 0;
}
static int __init init(void)
{
int i, ret=0;
u_int16_t port;
/* nornamlize the input */
normalize();
for (i=0;i<MAXPT_PORTS;i++)
memset(&pt[i], 0, sizeof(struct ip_conntrack_helper));
for (i = 0; i < entries && registered_port < MAXPT_PORTS; i++) {
for (port = pt_record[i].outport[0]; port <= pt_record[i].outport[1]; port++ ) {
pt[registered_port].max_expected = PTMAXEXPECTED;
// pt[registered_port].timeout = 0;
// pt[registered_port].flags = IP_CT_HELPER_F_REUSE_EXPECT;
//pt[registered_port].me = ip_conntrack_pt;
pt[registered_port].help = help;
if ( pt_record[i].outproto == 1 ) {
pt[registered_port].tuple.src.u.tcp.port = htons(port);
pt[registered_port].tuple.dst.protonum = IPPROTO_TCP;
pt[registered_port].mask.src.u.tcp.port = 0xFFFF;
pt[registered_port].mask.dst.protonum = 0xFFFF;
}
else if ( pt_record[i].outproto == 2 ) {
pt[registered_port].tuple.src.u.udp.port = htons(port);
pt[registered_port].tuple.dst.protonum = IPPROTO_UDP;
pt[registered_port].mask.src.u.udp.port = 0xFFFF;
pt[registered_port].mask.dst.protonum = 0xFFFF;
}
else {
pt[registered_port].tuple.src.u.all = htons(port);
pt[registered_port].mask.src.u.all = 0xFFFF;
pt[registered_port].mask.dst.protonum = 0;
}
DEBUGP("ip_conntrack_pt: registering helper for port %d\n",port);
if ( check_port(port) )
printk("ip_conntrack_pt: cannot register port %d (already registered by other module)\n",port);
else
ret = ip_conntrack_helper_register(&pt[registered_port++]);
if( registered_port >= MAXPT_PORTS ) {
printk( "Conntrack port forwarding table is full. Remaining entries are not processed.\n" );
pt_record[i].outport[1] = port;
entries = i + 1;
break;
}
if (ret) {
failed_port = port;
printk("ip_conntrack_pt: port %d register FAILED,port already registered \n",port);
fini();
return ret;
}
}
}
return 0;
}
static int __init init(void)
{
int port, ret;
char *tmpname;
/* If no port given, default to standard RSH port */
if (ports[0] == 0)
ports[0] = RSH_PORT;
/* the check on reserved port <1023 doesn't work with Legato */
/* for Legato NetWorker, the check should be that port <= 9936 */
if (range == 0)
range = 1023;
/* Legato uses range [ 7937 : 9936 ] -> 7937 by default */
rangemask = 0xffff ^ range; /* defaults to = 0xfc00 */
for (port = 0; (port < MAX_PORTS) && ports[port]; port++) {
memset(&rsh_helpers[port], 0, sizeof(struct ip_conntrack_helper));
tmpname = &rsh_names[port][0];
if (ports[port] == RSH_PORT)
sprintf(tmpname, "rsh");
else
sprintf(tmpname, "rsh-%d", ports[port]);
rsh_helpers[port].name = tmpname;
rsh_helpers[port].me = THIS_MODULE;
rsh_helpers[port].max_expected = 1;
rsh_helpers[port].timeout = 5; /* stes bug timeout=0 */
rsh_helpers[port].tuple.dst.protonum = IPPROTO_TCP;
rsh_helpers[port].mask.dst.protonum = 0xff;
/* RSH must come from ports 0:1023 to ports[port] (514) */
rsh_helpers[port].tuple.src.u.tcp.port = htons(ports[port]);
rsh_helpers[port].mask.src.u.tcp.port = htons(rangemask);
rsh_helpers[port].mask.dst.u.tcp.port = htons(rangemask);
rsh_helpers[port].help = help;
PRINTK("registering helper for port #%d: %d/TCP\n", port, ports[port]);
PRINTK("helper match ip %u.%u.%u.%u:%u-%u.%u.%u.%u:%u\n",
NIPQUAD(rsh_helpers[port].tuple.src.ip),
ntohs(rsh_helpers[port].tuple.src.u.tcp.port),
NIPQUAD(rsh_helpers[port].tuple.dst.ip),
ntohs(rsh_helpers[port].tuple.dst.u.tcp.port));
PRINTK("helper match mask %u.%u.%u.%u:%u-%u.%u.%u.%u:%u\n",
NIPQUAD(rsh_helpers[port].mask.src.ip),
ntohs(rsh_helpers[port].mask.src.u.tcp.port),
NIPQUAD(rsh_helpers[port].mask.dst.ip),
ntohs(rsh_helpers[port].mask.dst.u.tcp.port));
ret = ip_conntrack_helper_register(&rsh_helpers[port]);
if (ret) {
printk("ERROR registering port %d\n",
ports[port]);
fini();
return -EBUSY;
}
ports_n_c++;
}
return 0;
}
static int __init init(void)
{
return ip_conntrack_helper_register(&amanda_helper);
}
