Page MenuHomeFreeBSD
Differential D16840

multimedia/libxine: Update to 1.2.9; fix options; unmark broken
ClosedPublic
Actions

Authored by tobik on Aug 22 2018, 11:25 AM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Mar 27, 4:08 AM
Unknown Object (File)
Thu, Mar 27, 3:54 AM
Unknown Object (File)
Wed, Mar 26, 10:44 AM
Unknown Object (File)
Wed, Mar 26, 7:10 AM
Unknown Object (File)
Sun, Mar 23, 11:01 AM
Unknown Object (File)
Sat, Mar 22, 11:45 PM
Unknown Object (File)
Wed, Mar 19, 1:44 PM
Unknown Object (File)
Tue, Mar 18, 8:45 AM
View All Files
Subscribers
mat
tobik
Contributor Reviewers (ports)

Details

Reviewers
ndowens_yahoo.com
Commits
rP478529: multimedia/libxine: Update to 1.2.9
Summary

multimedia/libxine:

  • Update to 1.2.9
  • Added ImageMagick to default options
    • gxine needs it to build
  • Put options in alphabetical order
    • makes it easier to read/find options
  • Fixed with/enable options
    • configure options changed

Changelog:
https://sourceforge.net/projects/xine/
files/xine-lib/1.2.9/README.txt/view

Diff Detail

Repository
rP FreeBSD ports repository
Lint
No Lint Coverage
Unit
No Test Coverage
Build Status
Buildable 19073
Build 18704: arc lint + arc unit

Event Timeline

There are a very large number of changes, so older changes are hidden. Show Older Changes
tobik added inline comments.Aug 24 2018, 8:54 AM
multimedia/libxine/Makefile
82–83

This is still wrong.

Why does the previous way with

ESOUND_USE=	GNOME=esound

not work?

85–87
GNOMEVFS2_USE=	GNOME=glib20,gconf2,gnomevfs2
116–117

xineplug_dmx_image.so could previously be built with IMAGEMAGICK=off and PIBXUF=on or with IMAGEMAGICK=on and PIXBUF=off or with both on.

The WITH_DMX_IMAGE thing was a way to encode this in the plist. But we can achieve the same thing with a DMX_IMAGE option as @mat suggested. The plist entry for xineplug_dmx_image.so also needs to make use of it again.

ndowens_yahoo.com marked 6 inline comments as done.Aug 25 2018, 2:10 AM
ndowens_yahoo.com added inline comments.
multimedia/libxine/Makefile
61

Must have been accidentally removed

64

configure: error: DVB support requested, but DVB not found

> Script "configure" failed unexpectedly.

Please report the problem to ports@FreeBSD.org [maintainer] and attach the
"/usr/local/poudriere/ports/head/multimedia/libxine/work/xine-lib-1.2.9/config.log"
including the output of the failure of your make command. Also, it might be
a good idea to provide an overview of all packages installed on your system
(e.g. a /usr/local/sbin/pkg-static info -g -Ea).

  • Error code 1
85

Is actually needed to build with support . Same with esound

ndowens_yahoo.com updated this revision to Diff 47275.Aug 25 2018, 2:11 AM
ndowens_yahoo.com marked an inline comment as done.

Updating D16840: multimedia/libxine: Update to 1.2.9; fix options; unmark broken
Revised to use suggested changes

Harbormaster completed remote builds in B19166: Diff 47275.Aug 25 2018, 2:11 AM
mat added inline comments.Aug 25 2018, 6:28 AM
multimedia/libxine/pkg-plist
49–63

These seem to be strangely ordered. Please generate the plist with make makeplist and keep the order that it gives you.

ndowens_yahoo.com added inline comments.Aug 25 2018, 6:54 AM
multimedia/libxine/pkg-plist
49–63

Gonna have to do that, but try to put the OPTIONS in order as well, as for some reason OPTIONS_SUB=yes is not setting variables with make makeplist

ndowens_yahoo.com updated this revision to Diff 47281.Aug 25 2018, 7:01 AM

Updating D16840: multimedia/libxine: Update to 1.2.9; fix options; unmark broken
Sorted pkg-plist using vim :sort

Harbormaster completed remote builds in B19172: Diff 47281.Aug 25 2018, 7:01 AM
ndowens_yahoo.com marked 2 inline comments as done.Aug 25 2018, 7:02 AM
mat added inline comments.Aug 27 2018, 9:55 AM
multimedia/libxine/pkg-plist
49–63

I do not understand what variables make makeplist should set.

It is now even worse than before. Please run make makeplist and add the %%FOO%% back to it. Do not change the order of the lines in that file.

ndowens_yahoo.com updated this revision to Diff 47372.Aug 28 2018, 1:27 AM

Updating D16840: multimedia/libxine: Update to 1.2.9; fix options; unmark broken
Fixed plist ordering, per Mat

Harbormaster completed remote builds in B19231: Diff 47372.Aug 28 2018, 1:27 AM
mat added inline comments.Aug 28 2018, 7:39 PM
multimedia/libxine/Makefile
43

That comment is useless.
LLD_UNSAFE is only used on 12-CURRENT, so it is obvious.
You should either remove the comment, or make it useful, like saying why it is needed.

ndowens_yahoo.com updated this revision to Diff 47397.Aug 28 2018, 7:54 PM

Updating D16840: multimedia/libxine: Update to 1.2.9; fix options; unmark broken
Remove lld_unsafe comment

Harbormaster completed remote builds in B19246: Diff 47397.Aug 28 2018, 7:54 PM
ndowens_yahoo.com marked an inline comment as done.Aug 28 2018, 7:57 PM
tobik added inline comments.Aug 28 2018, 9:06 PM
multimedia/libxine/Makefile
64

The only reason this happens is because files/patch-configure was deleted. Please bring it back and put back --enable-dvb (or make it an option). It might need to be rebased but it still largely applies.

73

libxine has an sndio backend. Could you add an SNDIO option too?

multimedia/libxine/files/patch-configure
3–11

This hunk does not apply. Deleting it will make the patch usable against libxine 1.2.9.

26

DVB support on FreeBSD was patched in here.

multimedia/libxine/pkg-plist
26–27

Remove the extra whitespace at the beginning here.

ndowens_yahoo.com marked 4 inline comments as done.Aug 28 2018, 10:01 PM

Done, hope this is the last time of editing :) . Will upload updated one soon after testing

ndowens_yahoo.com updated this revision to Diff 47412.Aug 28 2018, 10:21 PM

Updating D16840: multimedia/libxine: Update to 1.2.9; fix options; unmark broken
Added Option for ipv6 while here, Added sndio for Tobik, fixed plist white-space; DVB option also added

Harbormaster completed remote builds in B19249: Diff 47412.Aug 28 2018, 10:21 PM
tobik added a comment.Aug 29 2018, 12:57 PM
In D16840#361163, @ndowens_yahoo.com wrote:

Done, hope this is the last time of editing :) . Will upload updated one soon after testing

Sorry, there are still problems.

multimedia/libxine/Makefile
44

In a quick test build I got

Error: /usr/local/lib/xine/plugins/2.7/xineplug_decode_spu.so is linked to /usr/local/lib/libdvdnav.so.4 from multimedia/libdvdnav but it is not declared as a dependency
Warning: you need LIB_DEPENDS+=libdvdnav.so:multimedia/libdvdnav

This was outside of Poudriere, so it might have been picked up accidentally. I'd suggest just adding it, because it looks like libxine would use a bundled libdvdnav otherwise. From a Poudriere build log:

checking for DVDNAV... no
*** no usable version of libdvdnav found, using internal copy ***
74

Enable DVB by default as it was before.

111–113

Thank you for adding it.

LIB_DEPENDS implies that the library must be available at both build and run time, so SNDIO_BUILD_DEPENDS should not really be needed.

multimedia/libxine/files/patch-src-libw32dll-wine-registry.c
1–13

This patch is still needed. It does not build in Poudriere on 10.4/i386 without it:

registry.c:140:55: error: use of undeclared identifier 'S_IRUSR'
        fd = xine_create_cloexec(localregpathname, O_WRONLY, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
                                                             ^
registry.c:140:63: error: use of undeclared identifier 'S_IWUSR'
        fd = xine_create_cloexec(localregpathname, O_WRONLY, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
                                                                     ^
registry.c:140:71: error: use of undeclared identifier 'S_IRGRP'
        fd = xine_create_cloexec(localregpathname, O_WRONLY, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
                                                                             ^
registry.c:140:79: error: use of undeclared identifier 'S_IROTH'
        fd = xine_create_cloexec(localregpathname, O_WRONLY, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
                                                                                     ^

There are plist problems on i386 too after readding it:

===> Checking for items in STAGEDIR missing from pkg-plist
Error: Orphaned: %%PLUGINSDIR%%/xineplug_decode_qt.so
Error: Orphaned: %%PLUGINSDIR%%/xineplug_decode_w32dll.so

Maybe adding a VIDIX option should be revisted?

multimedia/libxine/pkg-plist
74

Not sorted, move it below the pulseaudio one.

105

%%DVB%%

ndowens_yahoo.com marked 3 inline comments as done.Aug 29 2018, 1:22 PM
ndowens_yahoo.com added inline comments.
multimedia/libxine/pkg-plist
74

Mat said to make makeplist and use it’s ordering and add the options

Which I prefer more alphabetical ordering as well but that’s what I was told to do

105

Since it’s not gonna be an option, shouldn’t be need now

tobik added inline comments.Aug 29 2018, 1:30 PM
multimedia/libxine/pkg-plist
74

makeplist outputs:

%%PLUGINSDIR%%/xineplug_ao_out_pulseaudio.so
%%PLUGINSDIR%%/xineplug_ao_out_sndio.so

So please put the sndio plugin below pulseaudio.

105

I never said to remove the option. Just to put it into OPTIONS_DEFAULT.

ndowens_yahoo.com marked 3 inline comments as done.Aug 29 2018, 1:41 PM
ndowens_yahoo.com added inline comments.
multimedia/libxine/pkg-plist
105

Ah sorry misunderstood. As I remember it, it was not an option before so I thought that was what ya meant

ndowens_yahoo.com added a comment.Aug 29 2018, 1:43 PM

Will upload once I test again

tobik added a comment.EditedAug 29 2018, 3:32 PM

Build fails on 11.1/i386 in a different way too. Adding this patch from OpenBSD ports fixes it: https://raw.githubusercontent.com/openbsd/ports/master/multimedia/xine-lib/patches/patch-include_config_h

In file included from memcpy.c:36:
../../include/config.h:31:10: warning: "configure did not detect ARCH_X86_X32!" [-W#warnings]
#        warning "configure did not detect ARCH_X86_X32!"
         ^
memcpy.c:464:7: error: invalid operand for instruction
      BUMPPTR("64","0")
      ^
memcpy.c:145:34: note: expanded from macro 'BUMPPTR'
#  define BUMPPTR(offs,num)   "\n\tleaq\t"offs"(%q"num"), %q"num
                                 ^
<inline asm>:14:17: note: instantiated into assembly here
        leaq    64(%esi), %esi
                          ^~~~
memcpy.c:469:7: error: invalid operand for instruction
      BUMPPTR("64","1")
      ^
memcpy.c:145:34: note: expanded from macro 'BUMPPTR'
#  define BUMPPTR(offs,num)   "\n\tleaq\t"offs"(%q"num"), %q"num
                                 ^
<inline asm>:19:17: note: instantiated into assembly here
        leaq    64(%edi), %edi
                          ^~~~
ndowens_yahoo.com added a comment.Aug 29 2018, 4:07 PM
In D16840#361389, @tobik wrote:

Build fails on 11.1/i386 in a different way too. Adding this patch from OpenBSD ports fixes it: https://raw.githubusercontent.com/openbsd/ports/master/multimedia/xine-lib/patches/patch-include_config_h

In file included from memcpy.c:36:
../../include/config.h:31:10: warning: "configure did not detect ARCH_X86_X32!" [-W#warnings]
#        warning "configure did not detect ARCH_X86_X32!"
         ^
memcpy.c:464:7: error: invalid operand for instruction
      BUMPPTR("64","0")
      ^
memcpy.c:145:34: note: expanded from macro 'BUMPPTR'
#  define BUMPPTR(offs,num)   "\n\tleaq\t"offs"(%q"num"), %q"num
                                 ^
<inline asm>:14:17: note: instantiated into assembly here
        leaq    64(%esi), %esi
                          ^~~~
memcpy.c:469:7: error: invalid operand for instruction
      BUMPPTR("64","1")
      ^
memcpy.c:145:34: note: expanded from macro 'BUMPPTR'
#  define BUMPPTR(offs,num)   "\n\tleaq\t"offs"(%q"num"), %q"num
                                 ^
<inline asm>:19:17: note: instantiated into assembly here
        leaq    64(%edi), %edi
                          ^~~~

Wow this port is a pain. Currently testing 11-386 but it’s building reps atm. Sorry for all the mistakes previously popping back up. I randomly rollback ports to clean up and thought my diff stored elsewhere was up2date but wasn’t. Started pulling patch using arc lately to try and avoid as much as possible

ndowens_yahoo.com added a comment.Aug 29 2018, 4:35 PM

@tobik. Oh yea I took out vidix because when I looked at it previously I could not port the needed dep as it was too linux-centric and we don’t have the dep needed. So removed it from this coming update

ndowens_yahoo.com added a comment.EditedAug 29 2018, 7:25 PM

I got figure out what’s going on. On amd64 no pkg-list issue but on i386 there are orphaned pkgs. The only way I can think that may work is add something like if i386 plist”” else “@comment”

Or something similar as the options are the same on both archs

Edit: I think I may know what is doing it.

ndowens_yahoo.com updated this revision to Diff 47456.Aug 29 2018, 8:49 PM

Updating D16840: multimedia/libxine: Update to 1.2.9; fix options; unmark broken
Fixed plist; Added w32codec option, is a must in order to avoid plist issue on i386(seems only builds if i386)

Harbormaster completed remote builds in B19269: Diff 47456.Aug 29 2018, 8:49 PM
ndowens_yahoo.com updated this revision to Diff 47457.Aug 29 2018, 8:54 PM

Updating D16840: multimedia/libxine: Update to 1.2.9; fix options; unmark broken
Fixed messed up configure patch

Harbormaster completed remote builds in B19270: Diff 47457.Aug 29 2018, 8:54 PM
ndowens_yahoo.com updated this revision to Diff 47458.Aug 29 2018, 9:00 PM

Updating D16840: multimedia/libxine: Update to 1.2.9; fix options; unmark broken
Finished correcting configure patch

Harbormaster completed remote builds in B19271: Diff 47458.Aug 29 2018, 9:00 PM
ndowens_yahoo.com updated this revision to Diff 47465.Aug 29 2018, 11:36 PM

Updating D16840: multimedia/libxine: Update to 1.2.9; fix options; unmark broken
Found out that w32codecs build on i386 but not possible on amd64 as there is no /usr/local/bin/win32/
Edited to fix plist issue for either/or

Harbormaster completed remote builds in B19277: Diff 47465.Aug 29 2018, 11:36 PM
tobik commandeered this revision.Aug 30 2018, 7:51 AM
tobik added a reviewer: ndowens_yahoo.com.

It's good enough for me. Let me prepare this for a commit.

multimedia/libxine/Makefile
116–117

Oh, you brought the .if back :-(. I think the earlier attempt with an W32DLL option was much nicer and I think was the right approach.

116–117

You cannot use options helpers after .include <bsd.port.options.mk>. Options have been processed at that point. Any options helper must always be before it or bsd.port.pre.mk.

multimedia/libxine/files/patch-include-xine-xineutils.h
7–11

Patch is needed for building multimedia/phonon-xine:

In file included from xine/plugins.c:23:
In file included from /usr/local/include/xine/input_plugin.h:27:
/usr/local/include/xine/xineutils.h:197:8: error: unknown type name 'inline'
static inline void _x_freep(void *ptr) {
       ^
/usr/local/include/xine/xineutils.h:197:15: error: expected identifier or '('
static inline void _x_freep(void *ptr) {
              ^
2 errors generated.

I suppose we could add USE_CSTD=c99 to phonon-xine, but I think I prefer to just keep this patch.

tobik updated this revision to Diff 47476.Aug 30 2018, 7:53 AM
  • Add W32DLL i386-only option to properly handle the w32dll and qt plugins
  • Readd files/patch-include-xine-xineutils.h to fix the build of multimedia/phonon-xine
  • Remove unrecognized configure args
  • Add missing multimedia/xine and multimedia/vdr-plugin-xineliboutput PLUGINSDIR bumps
  • Add multimedia/gxine plist fix from D16854 (w/o the additional changes to keep it minimal here)

Test build on 10.4/i386 was fine, others still pending.

For the record these are the ports that depend on libxine

# Build with `OPTIONS_SET+=XINE LIBXINE` in make.conf
devel/efl
graphics/opencv
graphics/osg-devel
graphics/osg
graphics/gimageview
x11/eaglemode
audio/atunes
www/npapi-xine
multimedia/phonon-xine
multimedia/quark
multimedia/k9copy-kde4
multimedia/gxine
multimedia/vdr-plugin-xineliboutput
multimedia/subtitlecomposer-kde4
multimedia/xine
Harbormaster completed remote builds in B19284: Diff 47476.Aug 30 2018, 7:53 AM
tobik updated this revision to Diff 47477.Aug 30 2018, 7:54 AM
  • ABI is not 100% backwards compatible between 1.2.6 and 1.2.9 (see [1]), so bump revisions of all dependents just in case

[1] https://abi-laboratory.pro/index.php?view=timeline&l=xine-lib

Harbormaster completed remote builds in B19285: Diff 47477.Aug 30 2018, 7:54 AM
tobik updated this revision to Diff 47478.Aug 30 2018, 7:57 AM
  • Remove bogus post-install-VIDIX-on
Harbormaster completed remote builds in B19286: Diff 47478.Aug 30 2018, 7:57 AM
ndowens_yahoo.com added a comment.Aug 30 2018, 11:27 AM
In D16840#361623, @tobik wrote:
  • Add W32DLL i386-only option to properly handle the w32dll and qt plugins
  • Readd files/patch-include-xine-xineutils.h to fix the build of multimedia/phonon-xine
  • Remove unrecognized configure args
  • Add missing multimedia/xine and multimedia/vdr-plugin-xineliboutput PLUGINSDIR bumps
  • Add multimedia/gxine plist fix from D16854 (w/o the additional changes to keep it minimal here)

Test build on 10.4/i386 was fine, others still pending.

For the record these are the ports that depend on libxine

# Build with `OPTIONS_SET+=XINE LIBXINE` in make.conf
devel/efl
graphics/opencv
graphics/osg-devel
graphics/osg
graphics/gimageview
x11/eaglemode
audio/atunes
www/npapi-xine
multimedia/phonon-xine
multimedia/quark
multimedia/k9copy-kde4
multimedia/gxine
multimedia/vdr-plugin-xineliboutput
multimedia/subtitlecomposer-kde4
multimedia/xine

I’ve been working on the vdr-plugin-xineliboutput
It’s marked as broken on 12 current but I got it to built but it ends up missing two .so files that’s listed on pkg-plist

multimedia/libxine/Makefile
116–117

Ah looking at the Makefile didn’t remember could do option_plist

ndowens_yahoo.com added a comment.Aug 30 2018, 11:29 AM
This comment was removed by ndowens_yahoo.com.
ndowens_yahoo.com added a comment.Aug 30 2018, 11:47 AM

Patches aren’t applying cleanly for me after this revision

tobik added a comment.Aug 30 2018, 11:53 AM
In D16840#361661, @ndowens_yahoo.com wrote:

Patches aren’t applying cleanly for me after this revision

Can you provide more details please?

ndowens_yahoo.com added a comment.Aug 30 2018, 1:07 PM
In D16840#361662, @tobik wrote:
In D16840#361661, @ndowens_yahoo.com wrote:

Patches aren’t applying cleanly for me after this revision

Can you provide more details please?

https://gist.github.com/f4482b503c89ac347543de49e393ba68

ndowens_yahoo.com added a comment.Aug 30 2018, 1:22 PM
In D16840#361683, @ndowens_yahoo.com wrote:
In D16840#361662, @tobik wrote:
In D16840#361661, @ndowens_yahoo.com wrote:

Patches aren’t applying cleanly for me after this revision

Can you provide more details please?

https://gist.github.com/f4482b503c89ac347543de49e393ba68

Deleted my ports tree and svn co a new one to see if this helps

tobik added a comment.Aug 30 2018, 1:23 PM
In D16840#361683, @ndowens_yahoo.com wrote:
In D16840#361662, @tobik wrote:
In D16840#361661, @ndowens_yahoo.com wrote:

Patches aren’t applying cleanly for me after this revision

Can you provide more details please?

https://gist.github.com/f4482b503c89ac347543de49e393ba68

There seems to be some left over files and other unclean state in your ports tree checkout:

===>   Ignoring patchfile patch-configure.orig
===>   Ignoring patchfile patch-include-xine-xineutils.h.orig
===>   Ignoring patchfile patch-include_config.h.orig
Ignoring previously applied (or reversed) patch.
1 out of 1 hunks ignored--saving rejects to src/libw32dll/wine/registry.c.rej
Ignoring previously applied (or reversed) patch.
=> FreeBSD patch patch-src_libw32dll_wine_registry.c failed to apply cleanly.

How did you apply it? I'd suggest to cleanup the previous attempt and use svn patch D16840.diff or patch -E -V none -i D16840.diff.

ndowens_yahoo.com added a comment.Aug 30 2018, 1:24 PM
In D16840#361685, @tobik wrote:
In D16840#361683, @ndowens_yahoo.com wrote:
In D16840#361662, @tobik wrote:
In D16840#361661, @ndowens_yahoo.com wrote:

Patches aren’t applying cleanly for me after this revision

Can you provide more details please?

https://gist.github.com/f4482b503c89ac347543de49e393ba68

There seems to be some left over files and other unclean state in your ports tree checkout:

===>   Ignoring patchfile patch-configure.orig
===>   Ignoring patchfile patch-include-xine-xineutils.h.orig
===>   Ignoring patchfile patch-include_config.h.orig
Ignoring previously applied (or reversed) patch.
1 out of 1 hunks ignored--saving rejects to src/libw32dll/wine/registry.c.rej
Ignoring previously applied (or reversed) patch.
=> FreeBSD patch patch-src_libw32dll_wine_registry.c failed to apply cleanly.

How did you apply it? I'd suggest to cleanup the previous attempt and use svn patch D16840.diff or patch -E -V none -i D16840.diff.

I tried arc patch D16840

ndowens_yahoo.com added a comment.Aug 30 2018, 1:41 PM

Update after starting with clean ports it worked

ndowens_yahoo.com added a comment.Aug 30 2018, 2:05 PM

X11/eaglemode didn’t build on 12. I’ll work on that one next

ndowens_yahoo.com added a comment.Aug 31 2018, 1:03 AM
This comment was removed by ndowens_yahoo.com.
ndowens_yahoo.com added inline comments.Aug 31 2018, 1:05 AM
x11/eaglemode/Makefile
24 ↗(On Diff #47478)

Remove, doesn't work on 12

Replace with:
CFLAGS+= -fPIC

works for me on 12-current

This revision was not accepted when it landed; it landed in state Needs Review.Aug 31 2018, 8:16 AM
Closed by commit rP478529: multimedia/libxine: Update to 1.2.9 (authored by tobik). · Explain Why
This revision was automatically updated to reflect the committed changes.
tobik added inline comments.Aug 31 2018, 8:17 AM
x11/eaglemode/Makefile
24 ↗(On Diff #47478)

It looks like eaglemode does not respect LDFLAGS which is why LLD_UNSAFE is not working. You should run this by the maintainer.

x11/eaglemode was failing before on 12.0 and the libxine update hasn't made that worse, so I'd rather leave it as is for now and commit the update.

Revision Contents
Changeset List

Diff 47138

View Options

multimedia/libxine/Makefile

Show First 20 Lines • Show All 214 Lines • ▼ Show 20 Lines
/* Dummy port number codes used for FindLinkIn/Out() and AddLink(). /* Dummy port number codes used for FindLinkIn/Out() and AddLink().
These constants can be anything except zero, which indicates an These constants can be anything except zero, which indicates an
unknown port number. */ unknown port number. */
#define NO_DEST_PORT 1 #define NO_DEST_PORT 1
#define NO_SRC_PORT 1 #define NO_SRC_PORT 1
/* Dummy address used for FindLinkIn/Out() and AddLink(). /* Matches any/unknown address in FindLinkIn/Out() and AddLink(). */
The value of this variable is never used. */ static struct in_addr const ANY_ADDR = { INADDR_ANY };
static struct in_addr const NO_ADDR;
/* Data Structures /* Data Structures
The fundamental data structure used in this program is The fundamental data structure used in this program is
"struct alias_link". Whenever a TCP connection is made, "struct alias_link". Whenever a TCP connection is made,
a UDP datagram is sent out, or an ICMP echo request is made, a UDP datagram is sent out, or an ICMP echo request is made,
a link record is made (if it has not already been created). a link record is made (if it has not already been created).
The link record is identified by the source address/port The link record is identified by the source address/port
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
/* flag bits */ /* flag bits */
#define LINK_UNKNOWN_DEST_PORT 0x01 #define LINK_UNKNOWN_DEST_PORT 0x01
#define LINK_UNKNOWN_DEST_ADDR 0x02 #define LINK_UNKNOWN_DEST_ADDR 0x02
#define LINK_PERMANENT 0x04 #define LINK_PERMANENT 0x04
#define LINK_PARTIALLY_SPECIFIED 0x03 /* logical-or of first two bits */ #define LINK_PARTIALLY_SPECIFIED 0x03 /* logical-or of first two bits */
#define LINK_UNFIREWALLED 0x08 #define LINK_UNFIREWALLED 0x08
int timestamp; /* Time link was last accessed */ int timestamp; /* Time link was last accessed */
int expire_time; /* Expire time for link */
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
int sockfd; /* socket descriptor */ int sockfd; /* socket descriptor */
#endif #endif
/* Linked list of pointers for input and output lookup tables */ /* Linked list of pointers for input and output lookup tables */
LIST_ENTRY (alias_link) list_out; union {
LIST_ENTRY (alias_link) list_in; struct {
TAILQ_ENTRY (alias_link) list_expire; LIST_ENTRY(alias_link) in;
LIST_ENTRY(alias_link) out;
} all;
struct {
LIST_ENTRY(alias_link) list;
} pptp;
};
struct {
TAILQ_ENTRY(alias_link) list;
int timeout; /* Expire time for link */
} expire;
/* Auxiliary data */ /* Auxiliary data */
union { union {
char *frag_ptr; char *frag_ptr;
struct in_addr frag_addr; struct in_addr frag_addr;
struct tcp_dat *tcp; struct tcp_dat *tcp;
} data; } data;
}; };
Show All 36 Lines StartPointOut() -- link table initial search point for
outgoing packets outgoing packets
Miscellaneous: Miscellaneous:
SeqDiff() -- difference between two TCP sequences SeqDiff() -- difference between two TCP sequences
ShowAliasStats() -- send alias statistics to a monitor file ShowAliasStats() -- send alias statistics to a monitor file
*/ */
/* Local prototypes */ /* Local prototypes */
static u_int StartPointIn(struct in_addr, u_short, int); static struct group_in *
StartPointIn(struct libalias *, struct in_addr, u_short, int, int);
static u_int static u_int
StartPointOut(struct in_addr, struct in_addr, StartPointOut(struct in_addr, struct in_addr, u_short, u_short, int);
u_short, u_short, int);
static int SeqDiff(u_long, u_long); static int SeqDiff(u_long, u_long);
#ifndef NO_FW_PUNCH #ifndef NO_FW_PUNCH
/* Firewall control */ /* Firewall control */
static void InitPunchFW(struct libalias *); static void InitPunchFW(struct libalias *);
static void UninitPunchFW(struct libalias *); static void UninitPunchFW(struct libalias *);
static void ClearFWHole(struct alias_link *); static void ClearFWHole(struct alias_link *);
#endif #endif
/* Log file control */ /* Log file control */
static void ShowAliasStats(struct libalias *); static void ShowAliasStats(struct libalias *);
static int InitPacketAliasLog(struct libalias *); static int InitPacketAliasLog(struct libalias *);
static void UninitPacketAliasLog(struct libalias *); static void UninitPacketAliasLog(struct libalias *);
void SctpShowAliasStats(struct libalias *la); void SctpShowAliasStats(struct libalias *la);
static u_int #define INGUARD \
StartPointIn(struct in_addr alias_addr, if (grp->alias_port != alias_port || \
u_short alias_port, grp->link_type != link_type || \
int link_type) grp->alias_addr.s_addr != alias_addr.s_addr) \
continue;
static struct group_in *
StartPointIn(struct libalias *la,
struct in_addr alias_addr, u_short alias_port, int link_type,
int create)
{ {
u_int n; u_int n;
struct group_in *grp, *tmp;
n = alias_addr.s_addr; n = alias_addr.s_addr;
if (link_type != LINK_PPTP)
n += alias_port; n += alias_port;
n += link_type; n += link_type;
return (n % LINK_TABLE_IN_SIZE); n %= LINK_TABLE_IN_SIZE;
LIST_FOREACH_SAFE(grp, &la->groupTableIn[n], group_in, tmp) {
/* Auto cleanup */
if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {
LIST_REMOVE(grp, group_in);
free(grp);
} else {
INGUARD;
return (grp);
} }
}
if (!create || (grp = malloc(sizeof(*grp))) == NULL)
return (grp);
grp->alias_addr = alias_addr;
grp->alias_port = alias_port;
grp->link_type = link_type;
LIST_INIT(&grp->full);
LIST_INIT(&grp->partial);
LIST_INSERT_HEAD(&la->groupTableIn[n], grp, group_in);
return (grp);
}
#undef INGUARD
static u_int static u_int
StartPointOut(struct in_addr src_addr, struct in_addr dst_addr, StartPointOut(struct in_addr src_addr, struct in_addr dst_addr,
u_short src_port, u_short dst_port, int link_type) u_short src_port, u_short dst_port, int link_type)
{ {
u_int n; u_int n;
n = src_addr.s_addr; n = src_addr.s_addr;
n += dst_addr.s_addr; n += dst_addr.s_addr;
if (link_type != LINK_PPTP) {
n += src_port; n += src_port;
n += dst_port; n += dst_port;
}
n += link_type; n += link_type;
return (n % LINK_TABLE_OUT_SIZE); return (n % LINK_TABLE_OUT_SIZE);
} }
static int static int
SeqDiff(u_long x, u_long y) SeqDiff(u_long x, u_long y)
{ {
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
/* Local prototypes */ /* Local prototypes */
static int GetNewPort(struct libalias *, struct alias_link *, int); static int GetNewPort(struct libalias *, struct alias_link *, int);
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
static u_short GetSocket(struct libalias *, u_short, int *, int); static u_short GetSocket(struct libalias *, u_short, int *, int);
#endif #endif
static void CleanupAliasData(struct libalias *); static void CleanupAliasData(struct libalias *);
static void CleanupLink(struct libalias *, struct alias_link **); static void CleanupLink(struct libalias *, struct alias_link **);
static void DeleteLink(struct alias_link **); static void DeleteLink(struct alias_link **);
static struct alias_link *
UseLink(struct libalias *, struct alias_link *);
static struct alias_link * static struct alias_link *
ReLink(struct alias_link *, ReLink(struct alias_link *,
struct in_addr, struct in_addr, struct in_addr, struct in_addr, struct in_addr, struct in_addr,
u_short, u_short, int, int); u_short, u_short, int, int);
static struct alias_link * static struct alias_link *
FindLinkOut(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int); FindLinkOut(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int);
static struct alias_link * static struct alias_link *
FindLinkIn(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int); FindLinkIn(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int);
#define ALIAS_PORT_BASE 0x08000 static u_short _RandomPort(struct libalias *la);
#define ALIAS_PORT_MASK 0x07fff
#define ALIAS_PORT_MASK_EVEN 0x07ffe
#define GET_NEW_PORT_MAX_ATTEMPTS 20 #define GET_NEW_PORT_MAX_ATTEMPTS 20
#define FIND_EVEN_ALIAS_BASE 1 /* get random port in network byte order */
static u_short
_RandomPort(struct libalias *la) {
u_short port;
port = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
return ntohs(port);
}
/* GetNewPort() allocates port numbers. Note that if a port number /* GetNewPort() allocates port numbers. Note that if a port number
is already in use, that does not mean that it cannot be used by is already in use, that does not mean that it cannot be used by
another link concurrently. This is because GetNewPort() looks for another link concurrently. This is because GetNewPort() looks for
unused triplets: (dest addr, dest port, alias port). */ unused triplets: (dest addr, dest port, alias port). */
static int static int
GetNewPort(struct libalias *la, struct alias_link *lnk, int alias_port_param) GetNewPort(struct libalias *la, struct alias_link *lnk, int alias_port_param)
{ {
int i; int i;
int max_trials; int max_trials;
u_short port_sys; u_short port;
u_short port_net;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* /*
* Description of alias_port_param for GetNewPort(). When * Description of alias_port_param for GetNewPort(). When
* this parameter is zero or positive, it precisely specifies * this parameter is zero or positive, it precisely specifies
* the port number. GetNewPort() will return this number * the port number. GetNewPort() will return this number
* without check that it is in use. * without check that it is in use.
*
* The aliasing port is automatically selected by one of
* two methods below:
*
* When this parameter is GET_ALIAS_PORT, it indicates to get * When this parameter is GET_ALIAS_PORT, it indicates to get
* a randomly selected port number. * a randomly selected port number.
*/ */
if (alias_port_param == GET_ALIAS_PORT) { if (alias_port_param >= 0 && alias_port_param < 0x10000) {
/*
* The aliasing port is automatically selected by one of
* two methods below:
*/
max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) {
/*
* When the PKT_ALIAS_SAME_PORTS option is chosen,
* the first try will be the actual source port. If
* this is already in use, the remainder of the
* trials will be random.
*/
port_net = lnk->src_port;
port_sys = ntohs(port_net);
} else if (la->aliasPortLower) {
/* First trial is a random port in the aliasing range. */
port_sys = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
port_net = htons(port_sys);
} else {
/* First trial and all subsequent are random. */
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
port_net = htons(port_sys);
}
} else if (alias_port_param >= 0 && alias_port_param < 0x10000) {
lnk->alias_port = (u_short) alias_port_param; lnk->alias_port = (u_short) alias_port_param;
return (0); return (0);
} else { }
if (alias_port_param != GET_ALIAS_PORT) {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/GetNewPort(): "); fprintf(stderr, "PacketAlias/GetNewPort(): ");
fprintf(stderr, "input parameter error\n"); fprintf(stderr, "input parameter error\n");
#endif #endif
return (-1); return (-1);
} }
max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
/*
* When the PKT_ALIAS_SAME_PORTS option is chosen,
* the first try will be the actual source port. If
* this is already in use, the remainder of the
* trials will be random.
*/
port = (la->packetAliasMode & PKT_ALIAS_SAME_PORTS)
? lnk->src_port
: _RandomPort(la);
/* Port number search */ /* Port number search */
for (i = 0; i < max_trials; i++) { for (i = 0; i < max_trials; i++, port = _RandomPort(la)) {
int go_ahead; struct group_in *grp;
struct alias_link *search_result; struct alias_link *search_result;
search_result = FindLinkIn(la, lnk->dst_addr, lnk->alias_addr, grp = StartPointIn(la, lnk->alias_addr, port, lnk->link_type, 0);
lnk->dst_port, port_net, if (grp == NULL)
lnk->link_type, 0); break;
LIST_FOREACH(search_result, &grp->full, all.in) {
if (lnk->dst_addr.s_addr == search_result->dst_addr.s_addr &&
lnk->dst_port == search_result->dst_port)
break; /* found match */
}
if (search_result == NULL) if (search_result == NULL)
go_ahead = 1; break;
else if (!(lnk->flags & LINK_PARTIALLY_SPECIFIED)
&& (search_result->flags & LINK_PARTIALLY_SPECIFIED))
go_ahead = 1;
else
go_ahead = 0;
if (go_ahead) {
#ifndef NO_USE_SOCKETS
if ((la->packetAliasMode & PKT_ALIAS_USE_SOCKETS)
&& (lnk->flags & LINK_PARTIALLY_SPECIFIED)
&& ((lnk->link_type == LINK_TCP) ||
(lnk->link_type == LINK_UDP))) {
if (GetSocket(la, port_net, &lnk->sockfd, lnk->link_type)) {
lnk->alias_port = port_net;
return (0);
} }
} else {
#endif
lnk->alias_port = port_net;
return (0);
#ifndef NO_USE_SOCKETS
}
#endif
}
if (la->aliasPortLower) {
port_sys = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
port_net = htons(port_sys);
} else {
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
port_net = htons(port_sys);
}
}
if (i >= max_trials) {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/GetNewPort(): "); fprintf(stderr, "PacketAlias/GetNewPort(): ");
fprintf(stderr, "could not find free port\n"); fprintf(stderr, "could not find free port\n");
#endif #endif
return (-1);
}
#ifndef NO_USE_SOCKETS
if ((la->packetAliasMode & PKT_ALIAS_USE_SOCKETS) &&
(lnk->flags & LINK_PARTIALLY_SPECIFIED) &&
((lnk->link_type == LINK_TCP) ||
(lnk->link_type == LINK_UDP))) {
if (!GetSocket(la, port, &lnk->sockfd, lnk->link_type)) {
return (-1); return (-1);
} }
}
#endif
lnk->alias_port = port;
return (0);
}
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
static u_short static u_short
GetSocket(struct libalias *la, u_short port_net, int *sockfd, int link_type) GetSocket(struct libalias *la, u_short port_net, int *sockfd, int link_type)
{ {
int err; int err;
int sock; int sock;
struct sockaddr_in sock_addr; struct sockaddr_in sock_addr;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 LinesFindNewPortGroup(struct libalias *la,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
u_short port_count, u_short port_count,
u_char proto, u_char proto,
u_char align) u_char align)
{ {
int i, j; int i, j;
int max_trials; int max_trials;
u_short port_sys; u_short port;
int link_type; int link_type;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* /*
* Get link_type from protocol * Get link_type from protocol
*/ */
switch (proto) { switch (proto) {
Show All 15 LinesFindNewPortGroup(struct libalias *la,
max_trials = GET_NEW_PORT_MAX_ATTEMPTS; max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) { if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) {
/* /*
* When the ALIAS_SAME_PORTS option is chosen, the first * When the ALIAS_SAME_PORTS option is chosen, the first
* try will be the actual source port. If this is already * try will be the actual source port. If this is already
* in use, the remainder of the trials will be random. * in use, the remainder of the trials will be random.
*/ */
port_sys = ntohs(src_port); port = src_port;
} else { } else {
/* First trial and all subsequent are random. */ port = _RandomPort(la);
if (align == FIND_EVEN_ALIAS_BASE)
port_sys = arc4random() & ALIAS_PORT_MASK_EVEN;
else
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
} }
/* Port number search */ /* Port number search */
for (i = 0; i < max_trials; i++) { for (i = 0; i < max_trials; i++, port = _RandomPort(la)) {
struct alias_link *search_result; struct alias_link *search_result;
for (j = 0; j < port_count; j++) if (align)
port &= htons(0xfffe);
for (j = 0; j < port_count; j++) {
u_short port_j = ntohs(port) + j;
if ((search_result = FindLinkIn(la, dst_addr, if ((search_result = FindLinkIn(la, dst_addr,
alias_addr, dst_port, htons(port_sys + j), alias_addr, dst_port, htons(port_j),
link_type, 0)) != NULL) link_type, 0)) != NULL)
break; break;
}
/* Found a good range, return base */ /* Found a good range, return base */
if (j == port_count) if (j == port_count)
return (htons(port_sys)); return (port);
/* Find a new base to try */
if (align == FIND_EVEN_ALIAS_BASE)
port_sys = arc4random() & ALIAS_PORT_MASK_EVEN;
else
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
} }
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/FindNewPortGroup(): "); fprintf(stderr, "PacketAlias/FindNewPortGroup(): ");
fprintf(stderr, "could not find free port(s)\n"); fprintf(stderr, "could not find free port(s)\n");
#endif #endif
return (0); return (0);
} }
static void static void
CleanupAliasData(struct libalias *la) CleanupAliasData(struct libalias *la)
{ {
struct alias_link *lnk, *lnk_tmp; struct alias_link *lnk, *lnk_tmp;
u_int i;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* permanent entries may stay */ /* permanent entries may stay */
TAILQ_FOREACH_SAFE(lnk, &la->checkExpire, list_expire, lnk_tmp) TAILQ_FOREACH_SAFE(lnk, &la->checkExpire, expire.list, lnk_tmp)
DeleteLink(&lnk); DeleteLink(&lnk);
for (i = 0; i < LINK_TABLE_IN_SIZE; i++) {
struct group_in *grp, *grp_tmp;
LIST_FOREACH_SAFE(grp, &la->groupTableIn[i], group_in, grp_tmp)
if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {
LIST_REMOVE(grp, group_in);
free(grp);
} }
}
}
static void static void
CleanupLink(struct libalias *la, struct alias_link **lnk) CleanupLink(struct libalias *la, struct alias_link **lnk)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
if (lnk == NULL || *lnk == NULL) if (lnk == NULL || *lnk == NULL)
return; return;
if (LibAliasTime - (*lnk)->timestamp > (*lnk)->expire_time) { if (LibAliasTime - (*lnk)->timestamp > (*lnk)->expire.timeout) {
DeleteLink(lnk); DeleteLink(lnk);
if ((*lnk) == NULL) if ((*lnk) == NULL)
return; return;
} }
/* move to end, swap may fail on a single entry list */ /* move to end, swap may fail on a single entry list */
TAILQ_REMOVE(&la->checkExpire, (*lnk), list_expire); TAILQ_REMOVE(&la->checkExpire, (*lnk), expire.list);
TAILQ_INSERT_TAIL(&la->checkExpire, (*lnk), list_expire); TAILQ_INSERT_TAIL(&la->checkExpire, (*lnk), expire.list);
} }
static struct alias_link *
UseLink(struct libalias *la, struct alias_link *lnk)
{
CleanupLink(la, &lnk);
if (lnk != NULL)
lnk->timestamp = LibAliasTime;
return (lnk);
}
static void static void
DeleteLink(struct alias_link **plnk) DeleteLink(struct alias_link **plnk)
{ {
struct alias_link *lnk = *plnk; struct alias_link *lnk = *plnk;
struct libalias *la = lnk->la; struct libalias *la = lnk->la;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* Don't do anything if the link is marked permanent */ /* Don't do anything if the link is marked permanent */
if (la->deleteAllLinks == 0 && lnk->flags & LINK_PERMANENT) if (la->deleteAllLinks == 0 && lnk->flags & LINK_PERMANENT)
return; return;
#ifndef NO_FW_PUNCH #ifndef NO_FW_PUNCH
/* Delete associated firewall hole, if any */ /* Delete associated firewall hole, if any */
ClearFWHole(lnk); ClearFWHole(lnk);
#endif #endif
switch (lnk->link_type) {
case LINK_PPTP:
LIST_REMOVE(lnk, pptp.list);
break;
default:
/* Free memory allocated for LSNAT server pool */ /* Free memory allocated for LSNAT server pool */
if (lnk->server != NULL) { if (lnk->server != NULL) {
struct server *head, *curr, *next; struct server *head, *curr, *next;
head = curr = lnk->server; head = curr = lnk->server;
do { do {
next = curr->next; next = curr->next;
free(curr); free(curr);
} while ((curr = next) != head); } while ((curr = next) != head);
} } else {
/* Adjust output table pointers */ /* Adjust output table pointers */
LIST_REMOVE(lnk, list_out); LIST_REMOVE(lnk, all.out);
}
/* Adjust input table pointers */ /* Adjust input table pointers */
LIST_REMOVE(lnk, list_in); LIST_REMOVE(lnk, all.in);
break;
}
/* remove from housekeeping */ /* remove from housekeeping */
TAILQ_REMOVE(&la->checkExpire, lnk, list_expire); TAILQ_REMOVE(&la->checkExpire, lnk, expire.list);
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
/* Close socket, if one has been allocated */ /* Close socket, if one has been allocated */
if (lnk->sockfd != -1) { if (lnk->sockfd != -1) {
la->sockCount--; la->sockCount--;
close(lnk->sockfd); close(lnk->sockfd);
} }
#endif #endif
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
AddLink(struct libalias *la, struct in_addr src_addr, struct in_addr dst_addr, AddLink(struct libalias *la, struct in_addr src_addr, struct in_addr dst_addr,
struct in_addr alias_addr, u_short src_port, u_short dst_port, struct in_addr alias_addr, u_short src_port, u_short dst_port,
int alias_port_param, int link_type) int alias_port_param, int link_type)
{ {
u_int start_point; u_int start_point;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = malloc(sizeof(struct alias_link)); lnk = malloc(sizeof(struct alias_link));
if (lnk != NULL) { if (lnk == NULL) {
#ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink(): ");
fprintf(stderr, "malloc() call failed.\n");
#endif
return (NULL);
}
/* Basic initialization */ /* Basic initialization */
lnk->la = la; lnk->la = la;
lnk->src_addr = src_addr; lnk->src_addr = src_addr;
lnk->dst_addr = dst_addr; lnk->dst_addr = dst_addr;
lnk->alias_addr = alias_addr; lnk->alias_addr = alias_addr;
lnk->proxy_addr.s_addr = INADDR_ANY; lnk->proxy_addr.s_addr = INADDR_ANY;
lnk->src_port = src_port; lnk->src_port = src_port;
lnk->dst_port = dst_port; lnk->dst_port = dst_port;
lnk->proxy_port = 0; lnk->proxy_port = 0;
lnk->server = NULL; lnk->server = NULL;
lnk->link_type = link_type; lnk->link_type = link_type;
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
lnk->sockfd = -1; lnk->sockfd = -1;
#endif #endif
lnk->flags = 0; lnk->flags = 0;
lnk->pflags = 0; lnk->pflags = 0;
lnk->timestamp = LibAliasTime; lnk->timestamp = LibAliasTime;
/* Expiration time */ /* Expiration time */
switch (link_type) { switch (link_type) {
case LINK_ICMP: case LINK_ICMP:
lnk->expire_time = ICMP_EXPIRE_TIME; lnk->expire.timeout = ICMP_EXPIRE_TIME;
break; break;
case LINK_UDP: case LINK_UDP:
lnk->expire_time = UDP_EXPIRE_TIME; lnk->expire.timeout = UDP_EXPIRE_TIME;
break; break;
case LINK_TCP: case LINK_TCP:
lnk->expire_time = TCP_EXPIRE_INITIAL; lnk->expire.timeout = TCP_EXPIRE_INITIAL;
break; break;
case LINK_PPTP:
lnk->flags |= LINK_PERMANENT; /* no timeout. */
break;
case LINK_FRAGMENT_ID: case LINK_FRAGMENT_ID:
lnk->expire_time = FRAGMENT_ID_EXPIRE_TIME; lnk->expire.timeout = FRAGMENT_ID_EXPIRE_TIME;
break; break;
case LINK_FRAGMENT_PTR: case LINK_FRAGMENT_PTR:
lnk->expire_time = FRAGMENT_PTR_EXPIRE_TIME; lnk->expire.timeout = FRAGMENT_PTR_EXPIRE_TIME;
break; break;
case LINK_ADDR: case LINK_ADDR:
break; break;
default: default:
lnk->expire_time = PROTO_EXPIRE_TIME; lnk->expire.timeout = PROTO_EXPIRE_TIME;
break; break;
} }
/* Determine alias flags */ /* Determine alias flags */
if (dst_addr.s_addr == INADDR_ANY) if (dst_addr.s_addr == INADDR_ANY)
lnk->flags |= LINK_UNKNOWN_DEST_ADDR; lnk->flags |= LINK_UNKNOWN_DEST_ADDR;
if (dst_port == 0) if (dst_port == 0)
lnk->flags |= LINK_UNKNOWN_DEST_PORT; lnk->flags |= LINK_UNKNOWN_DEST_PORT;
/* Determine alias port */ /* Determine alias port */
if (GetNewPort(la, lnk, alias_port_param) != 0) { if (GetNewPort(la, lnk, alias_port_param) != 0) {
free(lnk); free(lnk);
return (NULL); return (NULL);
} }
/* Link-type dependent initialization */ /* Link-type dependent initialization */
switch (link_type) { switch (link_type) {
struct tcp_dat *aux_tcp;
case LINK_ICMP: case LINK_ICMP:
la->icmpLinkCount++; la->icmpLinkCount++;
break; break;
case LINK_UDP: case LINK_UDP:
la->udpLinkCount++; la->udpLinkCount++;
break; break;
case LINK_TCP: case LINK_TCP: {
struct tcp_dat *aux_tcp;
int i;
aux_tcp = malloc(sizeof(struct tcp_dat)); aux_tcp = malloc(sizeof(struct tcp_dat));
if (aux_tcp != NULL) { if (aux_tcp != NULL) {
int i; #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink: ");
fprintf(stderr, " cannot allocate auxiliary TCP data\n");
#endif
free(lnk);
return (NULL);
}
la->tcpLinkCount++; la->tcpLinkCount++;
aux_tcp->state.in = ALIAS_TCP_STATE_NOT_CONNECTED; aux_tcp->state.in = ALIAS_TCP_STATE_NOT_CONNECTED;
aux_tcp->state.out = ALIAS_TCP_STATE_NOT_CONNECTED; aux_tcp->state.out = ALIAS_TCP_STATE_NOT_CONNECTED;
aux_tcp->state.index = 0; aux_tcp->state.index = 0;
aux_tcp->state.ack_modified = 0; aux_tcp->state.ack_modified = 0;
for (i = 0; i < N_LINK_TCP_DATA; i++) for (i = 0; i < N_LINK_TCP_DATA; i++)
aux_tcp->ack[i].active = 0; aux_tcp->ack[i].active = 0;
aux_tcp->fwhole = -1; aux_tcp->fwhole = -1;
lnk->data.tcp = aux_tcp; lnk->data.tcp = aux_tcp;
} else {
#ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink: ");
fprintf(stderr, " cannot allocate auxiliary TCP data\n");
#endif
free(lnk);
return (NULL);
} }
break; break;
case LINK_PPTP: case LINK_PPTP:
la->pptpLinkCount++; la->pptpLinkCount++;
break; break;
case LINK_FRAGMENT_ID: case LINK_FRAGMENT_ID:
la->fragmentIdLinkCount++; la->fragmentIdLinkCount++;
break; break;
case LINK_FRAGMENT_PTR: case LINK_FRAGMENT_PTR:
la->fragmentPtrLinkCount++; la->fragmentPtrLinkCount++;
break; break;
case LINK_ADDR: case LINK_ADDR:
break; break;
default: default:
la->protoLinkCount++; la->protoLinkCount++;
break; break;
} }
switch (link_type) {
case LINK_PPTP:
LIST_INSERT_HEAD(&la->pptpTable, lnk, pptp.list);
break;
default: {
struct group_in *grp;
grp = StartPointIn(la, alias_addr, lnk->alias_port, link_type, 1);
if (grp == NULL) {
free(lnk);
return (NULL);
}
/* Set up pointers for output lookup table */ /* Set up pointers for output lookup table */
start_point = StartPointOut(src_addr, dst_addr, start_point = StartPointOut(src_addr, dst_addr,
src_port, dst_port, link_type); src_port, dst_port, link_type);
LIST_INSERT_HEAD(&la->linkTableOut[start_point], lnk, list_out); LIST_INSERT_HEAD(&la->linkTableOut[start_point], lnk, all.out);
/* Set up pointers for input lookup table */ /* Set up pointers for input lookup table */
start_point = StartPointIn(alias_addr, lnk->alias_port, link_type); if (lnk->flags & LINK_PARTIALLY_SPECIFIED)
LIST_INSERT_HEAD(&la->linkTableIn[start_point], lnk, list_in); LIST_INSERT_HEAD(&grp->partial, lnk, all.in);
else
LIST_INSERT_HEAD(&grp->full, lnk, all.in);
}
break;
}
/* Include the element into the housekeeping list */ /* Include the element into the housekeeping list */
TAILQ_INSERT_TAIL(&la->checkExpire, lnk, list_expire); TAILQ_INSERT_TAIL(&la->checkExpire, lnk, expire.list);
} else {
#ifdef LIBALIAS_DEBUG if (la->packetAliasMode & PKT_ALIAS_LOG)
fprintf(stderr, "PacketAlias/AddLink(): ");
fprintf(stderr, "malloc() call failed.\n");
#endif
}
if (la->packetAliasMode & PKT_ALIAS_LOG) {
ShowAliasStats(la); ShowAliasStats(la);
}
return (lnk); return (lnk);
} }
/* /*
* If alias_port_param is less than zero, alias port will be automatically * If alias_port_param is less than zero, alias port will be automatically
* chosen. If greater than zero, equal to alias port * chosen. If greater than zero, equal to alias port
*/ */
static struct alias_link * static struct alias_link *
Show All 19 Lines if (new_lnk != NULL &&
old_lnk->data.tcp->fwhole > 0) { old_lnk->data.tcp->fwhole > 0) {
PunchFWHole(new_lnk); PunchFWHole(new_lnk);
} }
#endif #endif
DeleteLink(&old_lnk); DeleteLink(&old_lnk);
return (new_lnk); return (new_lnk);
} }
#define OUTGUARD \
if (lnk->src_port != src_port || \
lnk->src_addr.s_addr != src_addr.s_addr || \
lnk->dst_addr.s_addr != dst_addr.s_addr || \
lnk->dst_port != dst_port || \
lnk->link_type != link_type) \
continue;
static struct alias_link * static struct alias_link *
_SearchLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr,
u_short src_port,
u_short dst_port,
int link_type) {
u_int i;
struct alias_link *lnk;
i = StartPointOut(src_addr, dst_addr, src_port, dst_port, link_type);
LIST_FOREACH(lnk, &la->linkTableOut[i], all.out) {
OUTGUARD;
return (UseLink(la, lnk));
}
return (NULL);
}
#undef OUTGUARD
static struct alias_link *
_FindLinkOut(struct libalias *la, struct in_addr src_addr, _FindLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
int link_type, int link_type,
int replace_partial_links) int replace_partial_links)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, src_port, dst_port, link_type); lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, dst_port, link_type);
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) { if (lnk != NULL || !replace_partial_links)
if (lnk->dst_addr.s_addr == dst_addr.s_addr && return (lnk);
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->src_port == src_port &&
lnk->dst_port == dst_port &&
lnk->link_type == link_type &&
lnk->server == NULL)
break;
}
CleanupLink(la, &lnk);
if (lnk != NULL)
lnk->timestamp = LibAliasTime;
/* Search for partially specified links. */ /* Search for partially specified links. */
if (lnk == NULL && replace_partial_links) {
if (dst_port != 0 && dst_addr.s_addr != INADDR_ANY) { if (dst_port != 0 && dst_addr.s_addr != INADDR_ANY) {
lnk = _FindLinkOut(la, src_addr, dst_addr, src_port, 0, lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, 0,
link_type, 0); link_type);
if (lnk == NULL) if (lnk == NULL)
lnk = _FindLinkOut(la, src_addr, NO_ADDR, src_port, lnk = _SearchLinkOut(la, src_addr, ANY_ADDR, src_port,
dst_port, link_type, 0); dst_port, link_type);
} }
if (lnk == NULL && if (lnk == NULL &&
(dst_port != 0 || dst_addr.s_addr != INADDR_ANY)) { (dst_port != 0 || dst_addr.s_addr != INADDR_ANY)) {
lnk = _FindLinkOut(la, src_addr, NO_ADDR, src_port, 0, lnk = _SearchLinkOut(la, src_addr, ANY_ADDR, src_port, 0,
link_type, 0); link_type);
} }
if (lnk != NULL) { if (lnk != NULL) {
lnk = ReLink(lnk, lnk = ReLink(lnk,
src_addr, dst_addr, lnk->alias_addr, src_addr, dst_addr, lnk->alias_addr,
src_port, dst_port, lnk->alias_port, src_port, dst_port, lnk->alias_port,
link_type); link_type);
} }
}
return (lnk); return (lnk);
} }
static struct alias_link * static struct alias_link *
FindLinkOut(struct libalias *la, struct in_addr src_addr, FindLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
Show All 10 Lines if (lnk == NULL) {
/* /*
* The following allows permanent links to be specified as * The following allows permanent links to be specified as
* using the default source address (i.e. device interface * using the default source address (i.e. device interface
* address) without knowing in advance what that address * address) without knowing in advance what that address
* is. * is.
*/ */
if (la->aliasAddress.s_addr != INADDR_ANY && if (la->aliasAddress.s_addr != INADDR_ANY &&
src_addr.s_addr == la->aliasAddress.s_addr) { src_addr.s_addr == la->aliasAddress.s_addr) {
lnk = _FindLinkOut(la, NO_ADDR, dst_addr, src_port, dst_port, lnk = _FindLinkOut(la, ANY_ADDR, dst_addr, src_port, dst_port,
link_type, replace_partial_links); link_type, replace_partial_links);
} }
} }
return (lnk); return (lnk);
} }
static struct alias_link * static struct alias_link *
_FindLinkIn(struct libalias *la, struct in_addr dst_addr, _FindLinkIn(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_short dst_port, u_short dst_port,
u_short alias_port, u_short alias_port,
int link_type, int link_type,
int replace_partial_links) int replace_partial_links)
{ {
int flags_in; int flags_in;
u_int start_point; struct group_in *grp;
struct alias_link *lnk; struct alias_link *lnk;
struct alias_link *lnk_fully_specified;
struct alias_link *lnk_unknown_all; struct alias_link *lnk_unknown_all;
struct alias_link *lnk_unknown_dst_addr; struct alias_link *lnk_unknown_dst_addr;
struct alias_link *lnk_unknown_dst_port; struct alias_link *lnk_unknown_dst_port;
struct in_addr src_addr;
u_short src_port;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* Initialize pointers */ /* Initialize pointers */
lnk_fully_specified = NULL;
lnk_unknown_all = NULL; lnk_unknown_all = NULL;
lnk_unknown_dst_addr = NULL; lnk_unknown_dst_addr = NULL;
lnk_unknown_dst_port = NULL; lnk_unknown_dst_port = NULL;
/* If either the dest addr or port is unknown, the search /* If either the dest addr or port is unknown, the search
* loop will have to know about this. */ * loop will have to know about this. */
flags_in = 0; flags_in = 0;
if (dst_addr.s_addr == INADDR_ANY) if (dst_addr.s_addr == INADDR_ANY)
flags_in |= LINK_UNKNOWN_DEST_ADDR; flags_in |= LINK_UNKNOWN_DEST_ADDR;
if (dst_port == 0) if (dst_port == 0)
flags_in |= LINK_UNKNOWN_DEST_PORT; flags_in |= LINK_UNKNOWN_DEST_PORT;
/* Search loop */ /* Search loop */
start_point = StartPointIn(alias_addr, alias_port, link_type); grp = StartPointIn(la, alias_addr, alias_port, link_type, 0);
LIST_FOREACH(lnk, &la->linkTableIn[start_point], list_in) { if (grp == NULL)
int flags; return (NULL);
flags = flags_in | lnk->flags; switch (flags_in) {
if (!(flags & LINK_PARTIALLY_SPECIFIED)) { case 0:
if (lnk->alias_addr.s_addr == alias_addr.s_addr LIST_FOREACH(lnk, &grp->full, all.in) {
&& lnk->alias_port == alias_port if (lnk->dst_addr.s_addr == dst_addr.s_addr &&
&& lnk->dst_addr.s_addr == dst_addr.s_addr lnk->dst_port == dst_port)
&& lnk->dst_port == dst_port return (UseLink(la, lnk));
&& lnk->link_type == link_type) { }
lnk_fully_specified = lnk;
break; break;
case LINK_UNKNOWN_DEST_PORT:
LIST_FOREACH(lnk, &grp->full, all.in) {
if(lnk->dst_addr.s_addr == dst_addr.s_addr) {
lnk_unknown_dst_port = lnk;
break;
} }
} else if ((flags & LINK_UNKNOWN_DEST_ADDR)
&& (flags & LINK_UNKNOWN_DEST_PORT)) {
if (lnk->alias_addr.s_addr == alias_addr.s_addr
&& lnk->alias_port == alias_port
&& lnk->link_type == link_type) {
if (lnk_unknown_all == NULL)
lnk_unknown_all = lnk;
} }
} else if (flags & LINK_UNKNOWN_DEST_ADDR) { break;
if (lnk->alias_addr.s_addr == alias_addr.s_addr case LINK_UNKNOWN_DEST_ADDR:
&& lnk->alias_port == alias_port LIST_FOREACH(lnk, &grp->full, all.in) {
&& lnk->link_type == link_type if(lnk->dst_port == dst_port) {
&& lnk->dst_port == dst_port) {
if (lnk_unknown_dst_addr == NULL)
lnk_unknown_dst_addr = lnk; lnk_unknown_dst_addr = lnk;
break;
} }
} else if (flags & LINK_UNKNOWN_DEST_PORT) { }
if (lnk->alias_addr.s_addr == alias_addr.s_addr break;
&& lnk->alias_port == alias_port case LINK_PARTIALLY_SPECIFIED:
&& lnk->link_type == link_type lnk_unknown_all = LIST_FIRST(&grp->full);
&& lnk->dst_addr.s_addr == dst_addr.s_addr) { break;
if (lnk_unknown_dst_port == NULL) }
if (lnk_unknown_dst_port == NULL) {
LIST_FOREACH(lnk, &grp->partial, all.in) {
int flags = (flags_in | lnk->flags) & LINK_PARTIALLY_SPECIFIED;
if (flags == LINK_PARTIALLY_SPECIFIED &&
lnk_unknown_all == NULL)
lnk_unknown_all = lnk;
if (flags == LINK_UNKNOWN_DEST_ADDR &&
lnk->dst_port == dst_port &&
lnk_unknown_dst_addr == NULL)
lnk_unknown_dst_addr = lnk;
if (flags == LINK_UNKNOWN_DEST_PORT &&
lnk->dst_addr.s_addr == dst_addr.s_addr) {
lnk_unknown_dst_port = lnk; lnk_unknown_dst_port = lnk;
break;
} }
} }
} }
CleanupLink(la, &lnk_fully_specified); lnk = (lnk_unknown_dst_port != NULL) ? lnk_unknown_dst_port
if (lnk_fully_specified != NULL) { : (lnk_unknown_dst_addr != NULL) ? lnk_unknown_dst_addr
lnk_fully_specified->timestamp = LibAliasTime; : lnk_unknown_all;
lnk = lnk_fully_specified;
} else if (lnk_unknown_dst_port != NULL)
lnk = lnk_unknown_dst_port;
else if (lnk_unknown_dst_addr != NULL)
lnk = lnk_unknown_dst_addr;
else if (lnk_unknown_all != NULL)
lnk = lnk_unknown_all;
else
return (NULL);
if (replace_partial_links && if (lnk == NULL || !replace_partial_links)
(lnk->flags & LINK_PARTIALLY_SPECIFIED || lnk->server != NULL)) { return (lnk);
struct in_addr src_addr;
u_short src_port;
if (lnk->server != NULL) { /* LSNAT link */ if (lnk->server != NULL) { /* LSNAT link */
src_addr = lnk->server->addr; src_addr = lnk->server->addr;
src_port = lnk->server->port; src_port = lnk->server->port;
lnk->server = lnk->server->next; lnk->server = lnk->server->next;
} else { } else {
src_addr = lnk->src_addr; src_addr = lnk->src_addr;
src_port = lnk->src_port; src_port = lnk->src_port;
} }
if (link_type == LINK_SCTP) { if (link_type == LINK_SCTP) {
lnk->src_addr = src_addr; lnk->src_addr = src_addr;
lnk->src_port = src_port; lnk->src_port = src_port;
return (lnk); } else {
}
lnk = ReLink(lnk, lnk = ReLink(lnk,
src_addr, dst_addr, alias_addr, src_addr, dst_addr, alias_addr,
src_port, dst_port, alias_port, src_port, dst_port, alias_port,
link_type); link_type);
} }
return (lnk); return (lnk);
} }
Show All 15 Lines if (lnk == NULL) {
/* /*
* The following allows permanent links to be specified as * The following allows permanent links to be specified as
* using the default aliasing address (i.e. device * using the default aliasing address (i.e. device
* interface address) without knowing in advance what that * interface address) without knowing in advance what that
* address is. * address is.
*/ */
if (la->aliasAddress.s_addr != INADDR_ANY && if (la->aliasAddress.s_addr != INADDR_ANY &&
alias_addr.s_addr == la->aliasAddress.s_addr) { alias_addr.s_addr == la->aliasAddress.s_addr) {
lnk = _FindLinkIn(la, dst_addr, NO_ADDR, dst_port, alias_port, lnk = _FindLinkIn(la, dst_addr, ANY_ADDR, dst_port, alias_port,
link_type, replace_partial_links); link_type, replace_partial_links);
} }
} }
return (lnk); return (lnk);
} }
/* External routines for finding/adding links /* External routines for finding/adding links
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 LinesFindFragmentIn1(struct libalias *la, struct in_addr dst_addr,
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, dst_addr, alias_addr, lnk = FindLinkIn(la, dst_addr, alias_addr,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID, 0); LINK_FRAGMENT_ID, 0);
if (lnk == NULL) { if (lnk == NULL) {
lnk = AddLink(la, NO_ADDR, dst_addr, alias_addr, lnk = AddLink(la, ANY_ADDR, dst_addr, alias_addr,
NO_SRC_PORT, NO_DEST_PORT, ip_id, NO_SRC_PORT, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID); LINK_FRAGMENT_ID);
} }
return (lnk); return (lnk);
} }
/* Doesn't add a link if one is not found. */ /* Doesn't add a link if one is not found. */
struct alias_link * struct alias_link *
FindFragmentIn2(struct libalias *la, struct in_addr dst_addr, FindFragmentIn2(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, u_short ip_id) struct in_addr alias_addr, u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return FindLinkIn(la, dst_addr, alias_addr, return FindLinkIn(la, dst_addr, alias_addr,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID, 0); LINK_FRAGMENT_ID, 0);
} }
struct alias_link * struct alias_link *
AddFragmentPtrLink(struct libalias *la, struct in_addr dst_addr, AddFragmentPtrLink(struct libalias *la, struct in_addr dst_addr,
u_short ip_id) u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return AddLink(la, NO_ADDR, dst_addr, NO_ADDR, return AddLink(la, ANY_ADDR, dst_addr, ANY_ADDR,
NO_SRC_PORT, NO_DEST_PORT, ip_id, NO_SRC_PORT, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_PTR); LINK_FRAGMENT_PTR);
} }
struct alias_link * struct alias_link *
FindFragmentPtr(struct libalias *la, struct in_addr dst_addr, FindFragmentPtr(struct libalias *la, struct in_addr dst_addr,
u_short ip_id) u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return FindLinkIn(la, dst_addr, NO_ADDR, return FindLinkIn(la, dst_addr, ANY_ADDR,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_PTR, 0); LINK_FRAGMENT_PTR, 0);
} }
struct alias_link * struct alias_link *
FindProtoIn(struct libalias *la, struct in_addr dst_addr, FindProtoIn(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_char proto) u_char proto)
▲ Show 20 Lines • Show All 131 Lines • ▼ Show 20 LinesAddPptp(struct libalias *la, struct in_addr src_addr,
return (lnk); return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpOutByCallId(struct libalias *la, struct in_addr src_addr, FindPptpOutByCallId(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_int16_t src_call_id) u_int16_t src_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, 0, 0, LINK_PPTP); LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) if (lnk->src_addr.s_addr == src_addr.s_addr &&
if (lnk->link_type == LINK_PPTP &&
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->src_port == src_call_id) lnk->src_port == src_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpOutByPeerCallId(struct libalias *la, struct in_addr src_addr, FindPptpOutByPeerCallId(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_int16_t dst_call_id) u_int16_t dst_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, 0, 0, LINK_PPTP); LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) if (lnk->src_addr.s_addr == src_addr.s_addr &&
if (lnk->link_type == LINK_PPTP &&
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->dst_port == dst_call_id) lnk->dst_port == dst_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpInByCallId(struct libalias *la, struct in_addr dst_addr, FindPptpInByCallId(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_int16_t dst_call_id) u_int16_t dst_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointIn(alias_addr, 0, LINK_PPTP);
LIST_FOREACH(lnk, &la->linkTableIn[i], list_in) LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
if (lnk->link_type == LINK_PPTP && if (lnk->dst_port == dst_call_id &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->alias_addr.s_addr == alias_addr.s_addr && lnk->alias_addr.s_addr == alias_addr.s_addr)
lnk->dst_port == dst_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpInByPeerCallId(struct libalias *la, struct in_addr dst_addr, FindPptpInByPeerCallId(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_int16_t alias_call_id) u_int16_t alias_call_id)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, dst_addr, alias_addr, LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
0 /* any */ , alias_call_id, if (lnk->alias_port == alias_call_id &&
LINK_PPTP, 0); lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->alias_addr.s_addr == alias_addr.s_addr)
break;
return (lnk); return (lnk);
} }
struct alias_link * struct alias_link *
FindRtspOut(struct libalias *la, struct in_addr src_addr, FindRtspOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
Show All 30 Lines
} }
struct in_addr struct in_addr
FindOriginalAddress(struct libalias *la, struct in_addr alias_addr) FindOriginalAddress(struct libalias *la, struct in_addr alias_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, NO_ADDR, alias_addr, lnk = FindLinkIn(la, ANY_ADDR, alias_addr,
0, 0, LINK_ADDR, 0); 0, 0, LINK_ADDR, 0);
if (lnk == NULL) { if (lnk == NULL) {
la->newDefaultLink = 1; la->newDefaultLink = 1;
if (la->targetAddress.s_addr == INADDR_ANY) if (la->targetAddress.s_addr == INADDR_ANY)
return (alias_addr); return (alias_addr);
else if (la->targetAddress.s_addr == INADDR_NONE) else if (la->targetAddress.s_addr == INADDR_NONE)
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : alias_addr; la->aliasAddress : alias_addr;
Show All 15 Lines
} }
struct in_addr struct in_addr
FindAliasAddress(struct libalias *la, struct in_addr original_addr) FindAliasAddress(struct libalias *la, struct in_addr original_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkOut(la, original_addr, NO_ADDR, lnk = FindLinkOut(la, original_addr, ANY_ADDR,
0, 0, LINK_ADDR, 0); 0, 0, LINK_ADDR, 0);
if (lnk == NULL) { if (lnk == NULL) {
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : original_addr; la->aliasAddress : original_addr;
} else { } else {
if (lnk->alias_addr.s_addr == INADDR_ANY) if (lnk->alias_addr.s_addr == INADDR_ANY)
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : original_addr; la->aliasAddress : original_addr;
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
void void
SetStateIn(struct alias_link *lnk, int state) SetStateIn(struct alias_link *lnk, int state)
{ {
/* TCP input state */ /* TCP input state */
switch (state) { switch (state) {
case ALIAS_TCP_STATE_DISCONNECTED: case ALIAS_TCP_STATE_DISCONNECTED:
if (lnk->data.tcp->state.out != ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.out != ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_DEAD; lnk->expire.timeout = TCP_EXPIRE_DEAD;
else else
lnk->expire_time = TCP_EXPIRE_SINGLEDEAD; lnk->expire.timeout = TCP_EXPIRE_SINGLEDEAD;
break; break;
case ALIAS_TCP_STATE_CONNECTED: case ALIAS_TCP_STATE_CONNECTED:
if (lnk->data.tcp->state.out == ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.out == ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_CONNECTED; lnk->expire.timeout = TCP_EXPIRE_CONNECTED;
break; break;
default: default:
#ifdef _KERNEL #ifdef _KERNEL
panic("libalias:SetStateIn() unknown state"); panic("libalias:SetStateIn() unknown state");
#else #else
abort(); abort();
#endif #endif
} }
lnk->data.tcp->state.in = state; lnk->data.tcp->state.in = state;
} }
void void
SetStateOut(struct alias_link *lnk, int state) SetStateOut(struct alias_link *lnk, int state)
{ {
/* TCP output state */ /* TCP output state */
switch (state) { switch (state) {
case ALIAS_TCP_STATE_DISCONNECTED: case ALIAS_TCP_STATE_DISCONNECTED:
if (lnk->data.tcp->state.in != ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.in != ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_DEAD; lnk->expire.timeout = TCP_EXPIRE_DEAD;
else else
lnk->expire_time = TCP_EXPIRE_SINGLEDEAD; lnk->expire.timeout = TCP_EXPIRE_SINGLEDEAD;
break; break;
case ALIAS_TCP_STATE_CONNECTED: case ALIAS_TCP_STATE_CONNECTED:
if (lnk->data.tcp->state.in == ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.in == ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_CONNECTED; lnk->expire.timeout = TCP_EXPIRE_CONNECTED;
break; break;
default: default:
#ifdef _KERNEL #ifdef _KERNEL
panic("libalias:SetStateOut() unknown state"); panic("libalias:SetStateOut() unknown state");
#else #else
abort(); abort();
#endif #endif
} }
▲ Show 20 Lines • Show All 232 Lines • ▼ Show 20 Lines
SetExpire(struct alias_link *lnk, int expire) SetExpire(struct alias_link *lnk, int expire)
{ {
if (expire == 0) { if (expire == 0) {
lnk->flags &= ~LINK_PERMANENT; lnk->flags &= ~LINK_PERMANENT;
DeleteLink(&lnk); DeleteLink(&lnk);
} else if (expire == -1) { } else if (expire == -1) {
lnk->flags |= LINK_PERMANENT; lnk->flags |= LINK_PERMANENT;
} else if (expire > 0) { } else if (expire > 0) {
lnk->expire_time = expire; lnk->expire.timeout = expire;
} else { } else {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/SetExpire(): "); fprintf(stderr, "PacketAlias/SetExpire(): ");
fprintf(stderr, "error in expire parameter\n"); fprintf(stderr, "error in expire parameter\n");
#endif #endif
} }
} }
▲ Show 20 Lines • Show All 187 Lines • ▼ Show 20 Lines
LibAliasAddServer(struct libalias *la, struct alias_link *lnk, struct in_addr addr, u_short port) LibAliasAddServer(struct libalias *la, struct alias_link *lnk, struct in_addr addr, u_short port)
{ {
struct server *server; struct server *server;
int res; int res;
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
(void)la; (void)la;
switch (lnk->link_type) {
case LINK_PPTP:
server = NULL;
break;
default:
server = malloc(sizeof(struct server)); server = malloc(sizeof(struct server));
break;
}
if (server != NULL) { if (server != NULL) {
struct server *head; struct server *head;
server->addr = addr; server->addr = addr;
server->port = port; server->port = port;
head = lnk->server; head = lnk->server;
if (head == NULL) if (head == NULL) {
server->next = server; server->next = server;
else { /* not usable for outgoing connections */
LIST_REMOVE(lnk, all.out);
} else {
struct server *s; struct server *s;
for (s = head; s->next != head; s = s->next) for (s = head; s->next != head; s = s->next)
; ;
s->next = server; s->next = server;
server->next = head; server->next = head;
} }
lnk->server = server; lnk->server = server;
Show All 37 Lines
/* Static address translation */ /* Static address translation */
struct alias_link * struct alias_link *
LibAliasRedirectAddr(struct libalias *la, struct in_addr src_addr, LibAliasRedirectAddr(struct libalias *la, struct in_addr src_addr,
struct in_addr alias_addr) struct in_addr alias_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
lnk = AddLink(la, src_addr, NO_ADDR, alias_addr, lnk = AddLink(la, src_addr, ANY_ADDR, alias_addr,
0, 0, 0, 0, 0, 0,
LINK_ADDR); LINK_ADDR);
if (lnk != NULL) { if (lnk != NULL) {
lnk->flags |= LINK_PERMANENT; lnk->flags |= LINK_PERMANENT;
} }
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
else { else {
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines#ifdef _KERNEL
LibAliasTime = time_uptime; LibAliasTime = time_uptime;
#else #else
LibAliasTime = time(NULL); LibAliasTime = time(NULL);
#endif #endif
for (i = 0; i < LINK_TABLE_OUT_SIZE; i++) for (i = 0; i < LINK_TABLE_OUT_SIZE; i++)
LIST_INIT(&la->linkTableOut[i]); LIST_INIT(&la->linkTableOut[i]);
for (i = 0; i < LINK_TABLE_IN_SIZE; i++) for (i = 0; i < LINK_TABLE_IN_SIZE; i++)
LIST_INIT(&la->linkTableIn[i]); LIST_INIT(&la->groupTableIn[i]);
LIST_INIT(&la->pptpTable);
TAILQ_INIT(&la->checkExpire); TAILQ_INIT(&la->checkExpire);
#ifdef _KERNEL #ifdef _KERNEL
AliasSctpInit(la); AliasSctpInit(la);
#endif #endif
LIBALIAS_LOCK_INIT(la); LIBALIAS_LOCK_INIT(la);
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
} else { } else {
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
la->deleteAllLinks = 1; la->deleteAllLinks = 1;
CleanupAliasData(la); CleanupAliasData(la);
la->deleteAllLinks = 0; la->deleteAllLinks = 0;
#ifdef _KERNEL #ifdef _KERNEL
AliasSctpTerm(la); AliasSctpTerm(la);
AliasSctpInit(la); AliasSctpInit(la);
#endif #endif
} }
la->aliasAddress.s_addr = INADDR_ANY; la->aliasAddress.s_addr = INADDR_ANY;
la->targetAddress.s_addr = INADDR_ANY; la->targetAddress.s_addr = INADDR_ANY;
la->aliasPortLower = 0x8000;
la->aliasPortLength = 0x8000;
la->icmpLinkCount = 0; la->icmpLinkCount = 0;
la->udpLinkCount = 0; la->udpLinkCount = 0;
la->tcpLinkCount = 0; la->tcpLinkCount = 0;
la->sctpLinkCount = 0; la->sctpLinkCount = 0;
la->pptpLinkCount = 0; la->pptpLinkCount = 0;
la->protoLinkCount = 0; la->protoLinkCount = 0;
la->fragmentIdLinkCount = 0; la->fragmentIdLinkCount = 0;
▲ Show 20 Lines • Show All 380 Lines • Show Last 20 Lines
View Options

multimedia/libxine/distinfo

Show First 20 Lines • Show All 214 Lines • ▼ Show 20 Lines
/* Dummy port number codes used for FindLinkIn/Out() and AddLink(). /* Dummy port number codes used for FindLinkIn/Out() and AddLink().
These constants can be anything except zero, which indicates an These constants can be anything except zero, which indicates an
unknown port number. */ unknown port number. */
#define NO_DEST_PORT 1 #define NO_DEST_PORT 1
#define NO_SRC_PORT 1 #define NO_SRC_PORT 1
/* Dummy address used for FindLinkIn/Out() and AddLink(). /* Matches any/unknown address in FindLinkIn/Out() and AddLink(). */
The value of this variable is never used. */ static struct in_addr const ANY_ADDR = { INADDR_ANY };
static struct in_addr const NO_ADDR;
/* Data Structures /* Data Structures
The fundamental data structure used in this program is The fundamental data structure used in this program is
"struct alias_link". Whenever a TCP connection is made, "struct alias_link". Whenever a TCP connection is made,
a UDP datagram is sent out, or an ICMP echo request is made, a UDP datagram is sent out, or an ICMP echo request is made,
a link record is made (if it has not already been created). a link record is made (if it has not already been created).
The link record is identified by the source address/port The link record is identified by the source address/port
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
/* flag bits */ /* flag bits */
#define LINK_UNKNOWN_DEST_PORT 0x01 #define LINK_UNKNOWN_DEST_PORT 0x01
#define LINK_UNKNOWN_DEST_ADDR 0x02 #define LINK_UNKNOWN_DEST_ADDR 0x02
#define LINK_PERMANENT 0x04 #define LINK_PERMANENT 0x04
#define LINK_PARTIALLY_SPECIFIED 0x03 /* logical-or of first two bits */ #define LINK_PARTIALLY_SPECIFIED 0x03 /* logical-or of first two bits */
#define LINK_UNFIREWALLED 0x08 #define LINK_UNFIREWALLED 0x08
int timestamp; /* Time link was last accessed */ int timestamp; /* Time link was last accessed */
int expire_time; /* Expire time for link */
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
int sockfd; /* socket descriptor */ int sockfd; /* socket descriptor */
#endif #endif
/* Linked list of pointers for input and output lookup tables */ /* Linked list of pointers for input and output lookup tables */
LIST_ENTRY (alias_link) list_out; union {
LIST_ENTRY (alias_link) list_in; struct {
TAILQ_ENTRY (alias_link) list_expire; LIST_ENTRY(alias_link) in;
LIST_ENTRY(alias_link) out;
} all;
struct {
LIST_ENTRY(alias_link) list;
} pptp;
};
struct {
TAILQ_ENTRY(alias_link) list;
int timeout; /* Expire time for link */
} expire;
/* Auxiliary data */ /* Auxiliary data */
union { union {
char *frag_ptr; char *frag_ptr;
struct in_addr frag_addr; struct in_addr frag_addr;
struct tcp_dat *tcp; struct tcp_dat *tcp;
} data; } data;
}; };
Show All 36 Lines StartPointOut() -- link table initial search point for
outgoing packets outgoing packets
Miscellaneous: Miscellaneous:
SeqDiff() -- difference between two TCP sequences SeqDiff() -- difference between two TCP sequences
ShowAliasStats() -- send alias statistics to a monitor file ShowAliasStats() -- send alias statistics to a monitor file
*/ */
/* Local prototypes */ /* Local prototypes */
static u_int StartPointIn(struct in_addr, u_short, int); static struct group_in *
StartPointIn(struct libalias *, struct in_addr, u_short, int, int);
static u_int static u_int
StartPointOut(struct in_addr, struct in_addr, StartPointOut(struct in_addr, struct in_addr, u_short, u_short, int);
u_short, u_short, int);
static int SeqDiff(u_long, u_long); static int SeqDiff(u_long, u_long);
#ifndef NO_FW_PUNCH #ifndef NO_FW_PUNCH
/* Firewall control */ /* Firewall control */
static void InitPunchFW(struct libalias *); static void InitPunchFW(struct libalias *);
static void UninitPunchFW(struct libalias *); static void UninitPunchFW(struct libalias *);
static void ClearFWHole(struct alias_link *); static void ClearFWHole(struct alias_link *);
#endif #endif
/* Log file control */ /* Log file control */
static void ShowAliasStats(struct libalias *); static void ShowAliasStats(struct libalias *);
static int InitPacketAliasLog(struct libalias *); static int InitPacketAliasLog(struct libalias *);
static void UninitPacketAliasLog(struct libalias *); static void UninitPacketAliasLog(struct libalias *);
void SctpShowAliasStats(struct libalias *la); void SctpShowAliasStats(struct libalias *la);
static u_int #define INGUARD \
StartPointIn(struct in_addr alias_addr, if (grp->alias_port != alias_port || \
u_short alias_port, grp->link_type != link_type || \
int link_type) grp->alias_addr.s_addr != alias_addr.s_addr) \
continue;
static struct group_in *
StartPointIn(struct libalias *la,
struct in_addr alias_addr, u_short alias_port, int link_type,
int create)
{ {
u_int n; u_int n;
struct group_in *grp, *tmp;
n = alias_addr.s_addr; n = alias_addr.s_addr;
if (link_type != LINK_PPTP)
n += alias_port; n += alias_port;
n += link_type; n += link_type;
return (n % LINK_TABLE_IN_SIZE); n %= LINK_TABLE_IN_SIZE;
LIST_FOREACH_SAFE(grp, &la->groupTableIn[n], group_in, tmp) {
/* Auto cleanup */
if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {
LIST_REMOVE(grp, group_in);
free(grp);
} else {
INGUARD;
return (grp);
} }
}
if (!create || (grp = malloc(sizeof(*grp))) == NULL)
return (grp);
grp->alias_addr = alias_addr;
grp->alias_port = alias_port;
grp->link_type = link_type;
LIST_INIT(&grp->full);
LIST_INIT(&grp->partial);
LIST_INSERT_HEAD(&la->groupTableIn[n], grp, group_in);
return (grp);
}
#undef INGUARD
static u_int static u_int
StartPointOut(struct in_addr src_addr, struct in_addr dst_addr, StartPointOut(struct in_addr src_addr, struct in_addr dst_addr,
u_short src_port, u_short dst_port, int link_type) u_short src_port, u_short dst_port, int link_type)
{ {
u_int n; u_int n;
n = src_addr.s_addr; n = src_addr.s_addr;
n += dst_addr.s_addr; n += dst_addr.s_addr;
if (link_type != LINK_PPTP) {
n += src_port; n += src_port;
n += dst_port; n += dst_port;
}
n += link_type; n += link_type;
return (n % LINK_TABLE_OUT_SIZE); return (n % LINK_TABLE_OUT_SIZE);
} }
static int static int
SeqDiff(u_long x, u_long y) SeqDiff(u_long x, u_long y)
{ {
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
/* Local prototypes */ /* Local prototypes */
static int GetNewPort(struct libalias *, struct alias_link *, int); static int GetNewPort(struct libalias *, struct alias_link *, int);
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
static u_short GetSocket(struct libalias *, u_short, int *, int); static u_short GetSocket(struct libalias *, u_short, int *, int);
#endif #endif
static void CleanupAliasData(struct libalias *); static void CleanupAliasData(struct libalias *);
static void CleanupLink(struct libalias *, struct alias_link **); static void CleanupLink(struct libalias *, struct alias_link **);
static void DeleteLink(struct alias_link **); static void DeleteLink(struct alias_link **);
static struct alias_link *
UseLink(struct libalias *, struct alias_link *);
static struct alias_link * static struct alias_link *
ReLink(struct alias_link *, ReLink(struct alias_link *,
struct in_addr, struct in_addr, struct in_addr, struct in_addr, struct in_addr, struct in_addr,
u_short, u_short, int, int); u_short, u_short, int, int);
static struct alias_link * static struct alias_link *
FindLinkOut(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int); FindLinkOut(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int);
static struct alias_link * static struct alias_link *
FindLinkIn(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int); FindLinkIn(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int);
#define ALIAS_PORT_BASE 0x08000 static u_short _RandomPort(struct libalias *la);
#define ALIAS_PORT_MASK 0x07fff
#define ALIAS_PORT_MASK_EVEN 0x07ffe
#define GET_NEW_PORT_MAX_ATTEMPTS 20 #define GET_NEW_PORT_MAX_ATTEMPTS 20
#define FIND_EVEN_ALIAS_BASE 1 /* get random port in network byte order */
static u_short
_RandomPort(struct libalias *la) {
u_short port;
port = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
return ntohs(port);
}
/* GetNewPort() allocates port numbers. Note that if a port number /* GetNewPort() allocates port numbers. Note that if a port number
is already in use, that does not mean that it cannot be used by is already in use, that does not mean that it cannot be used by
another link concurrently. This is because GetNewPort() looks for another link concurrently. This is because GetNewPort() looks for
unused triplets: (dest addr, dest port, alias port). */ unused triplets: (dest addr, dest port, alias port). */
static int static int
GetNewPort(struct libalias *la, struct alias_link *lnk, int alias_port_param) GetNewPort(struct libalias *la, struct alias_link *lnk, int alias_port_param)
{ {
int i; int i;
int max_trials; int max_trials;
u_short port_sys; u_short port;
u_short port_net;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* /*
* Description of alias_port_param for GetNewPort(). When * Description of alias_port_param for GetNewPort(). When
* this parameter is zero or positive, it precisely specifies * this parameter is zero or positive, it precisely specifies
* the port number. GetNewPort() will return this number * the port number. GetNewPort() will return this number
* without check that it is in use. * without check that it is in use.
*
* The aliasing port is automatically selected by one of
* two methods below:
*
* When this parameter is GET_ALIAS_PORT, it indicates to get * When this parameter is GET_ALIAS_PORT, it indicates to get
* a randomly selected port number. * a randomly selected port number.
*/ */
if (alias_port_param == GET_ALIAS_PORT) { if (alias_port_param >= 0 && alias_port_param < 0x10000) {
/*
* The aliasing port is automatically selected by one of
* two methods below:
*/
max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) {
/*
* When the PKT_ALIAS_SAME_PORTS option is chosen,
* the first try will be the actual source port. If
* this is already in use, the remainder of the
* trials will be random.
*/
port_net = lnk->src_port;
port_sys = ntohs(port_net);
} else if (la->aliasPortLower) {
/* First trial is a random port in the aliasing range. */
port_sys = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
port_net = htons(port_sys);
} else {
/* First trial and all subsequent are random. */
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
port_net = htons(port_sys);
}
} else if (alias_port_param >= 0 && alias_port_param < 0x10000) {
lnk->alias_port = (u_short) alias_port_param; lnk->alias_port = (u_short) alias_port_param;
return (0); return (0);
} else { }
if (alias_port_param != GET_ALIAS_PORT) {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/GetNewPort(): "); fprintf(stderr, "PacketAlias/GetNewPort(): ");
fprintf(stderr, "input parameter error\n"); fprintf(stderr, "input parameter error\n");
#endif #endif
return (-1); return (-1);
} }
max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
/*
* When the PKT_ALIAS_SAME_PORTS option is chosen,
* the first try will be the actual source port. If
* this is already in use, the remainder of the
* trials will be random.
*/
port = (la->packetAliasMode & PKT_ALIAS_SAME_PORTS)
? lnk->src_port
: _RandomPort(la);
/* Port number search */ /* Port number search */
for (i = 0; i < max_trials; i++) { for (i = 0; i < max_trials; i++, port = _RandomPort(la)) {
int go_ahead; struct group_in *grp;
struct alias_link *search_result; struct alias_link *search_result;
search_result = FindLinkIn(la, lnk->dst_addr, lnk->alias_addr, grp = StartPointIn(la, lnk->alias_addr, port, lnk->link_type, 0);
lnk->dst_port, port_net, if (grp == NULL)
lnk->link_type, 0); break;
LIST_FOREACH(search_result, &grp->full, all.in) {
if (lnk->dst_addr.s_addr == search_result->dst_addr.s_addr &&
lnk->dst_port == search_result->dst_port)
break; /* found match */
}
if (search_result == NULL) if (search_result == NULL)
go_ahead = 1; break;
else if (!(lnk->flags & LINK_PARTIALLY_SPECIFIED)
&& (search_result->flags & LINK_PARTIALLY_SPECIFIED))
go_ahead = 1;
else
go_ahead = 0;
if (go_ahead) {
#ifndef NO_USE_SOCKETS
if ((la->packetAliasMode & PKT_ALIAS_USE_SOCKETS)
&& (lnk->flags & LINK_PARTIALLY_SPECIFIED)
&& ((lnk->link_type == LINK_TCP) ||
(lnk->link_type == LINK_UDP))) {
if (GetSocket(la, port_net, &lnk->sockfd, lnk->link_type)) {
lnk->alias_port = port_net;
return (0);
} }
} else {
#endif
lnk->alias_port = port_net;
return (0);
#ifndef NO_USE_SOCKETS
}
#endif
}
if (la->aliasPortLower) {
port_sys = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
port_net = htons(port_sys);
} else {
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
port_net = htons(port_sys);
}
}
if (i >= max_trials) {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/GetNewPort(): "); fprintf(stderr, "PacketAlias/GetNewPort(): ");
fprintf(stderr, "could not find free port\n"); fprintf(stderr, "could not find free port\n");
#endif #endif
return (-1);
}
#ifndef NO_USE_SOCKETS
if ((la->packetAliasMode & PKT_ALIAS_USE_SOCKETS) &&
(lnk->flags & LINK_PARTIALLY_SPECIFIED) &&
((lnk->link_type == LINK_TCP) ||
(lnk->link_type == LINK_UDP))) {
if (!GetSocket(la, port, &lnk->sockfd, lnk->link_type)) {
return (-1); return (-1);
} }
}
#endif
lnk->alias_port = port;
return (0);
}
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
static u_short static u_short
GetSocket(struct libalias *la, u_short port_net, int *sockfd, int link_type) GetSocket(struct libalias *la, u_short port_net, int *sockfd, int link_type)
{ {
int err; int err;
int sock; int sock;
struct sockaddr_in sock_addr; struct sockaddr_in sock_addr;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 LinesFindNewPortGroup(struct libalias *la,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
u_short port_count, u_short port_count,
u_char proto, u_char proto,
u_char align) u_char align)
{ {
int i, j; int i, j;
int max_trials; int max_trials;
u_short port_sys; u_short port;
int link_type; int link_type;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* /*
* Get link_type from protocol * Get link_type from protocol
*/ */
switch (proto) { switch (proto) {
Show All 15 LinesFindNewPortGroup(struct libalias *la,
max_trials = GET_NEW_PORT_MAX_ATTEMPTS; max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) { if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) {
/* /*
* When the ALIAS_SAME_PORTS option is chosen, the first * When the ALIAS_SAME_PORTS option is chosen, the first
* try will be the actual source port. If this is already * try will be the actual source port. If this is already
* in use, the remainder of the trials will be random. * in use, the remainder of the trials will be random.
*/ */
port_sys = ntohs(src_port); port = src_port;
} else { } else {
/* First trial and all subsequent are random. */ port = _RandomPort(la);
if (align == FIND_EVEN_ALIAS_BASE)
port_sys = arc4random() & ALIAS_PORT_MASK_EVEN;
else
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
} }
/* Port number search */ /* Port number search */
for (i = 0; i < max_trials; i++) { for (i = 0; i < max_trials; i++, port = _RandomPort(la)) {
struct alias_link *search_result; struct alias_link *search_result;
for (j = 0; j < port_count; j++) if (align)
port &= htons(0xfffe);
for (j = 0; j < port_count; j++) {
u_short port_j = ntohs(port) + j;
if ((search_result = FindLinkIn(la, dst_addr, if ((search_result = FindLinkIn(la, dst_addr,
alias_addr, dst_port, htons(port_sys + j), alias_addr, dst_port, htons(port_j),
link_type, 0)) != NULL) link_type, 0)) != NULL)
break; break;
}
/* Found a good range, return base */ /* Found a good range, return base */
if (j == port_count) if (j == port_count)
return (htons(port_sys)); return (port);
/* Find a new base to try */
if (align == FIND_EVEN_ALIAS_BASE)
port_sys = arc4random() & ALIAS_PORT_MASK_EVEN;
else
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
} }
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/FindNewPortGroup(): "); fprintf(stderr, "PacketAlias/FindNewPortGroup(): ");
fprintf(stderr, "could not find free port(s)\n"); fprintf(stderr, "could not find free port(s)\n");
#endif #endif
return (0); return (0);
} }
static void static void
CleanupAliasData(struct libalias *la) CleanupAliasData(struct libalias *la)
{ {
struct alias_link *lnk, *lnk_tmp; struct alias_link *lnk, *lnk_tmp;
u_int i;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* permanent entries may stay */ /* permanent entries may stay */
TAILQ_FOREACH_SAFE(lnk, &la->checkExpire, list_expire, lnk_tmp) TAILQ_FOREACH_SAFE(lnk, &la->checkExpire, expire.list, lnk_tmp)
DeleteLink(&lnk); DeleteLink(&lnk);
for (i = 0; i < LINK_TABLE_IN_SIZE; i++) {
struct group_in *grp, *grp_tmp;
LIST_FOREACH_SAFE(grp, &la->groupTableIn[i], group_in, grp_tmp)
if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {
LIST_REMOVE(grp, group_in);
free(grp);
} }
}
}
static void static void
CleanupLink(struct libalias *la, struct alias_link **lnk) CleanupLink(struct libalias *la, struct alias_link **lnk)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
if (lnk == NULL || *lnk == NULL) if (lnk == NULL || *lnk == NULL)
return; return;
if (LibAliasTime - (*lnk)->timestamp > (*lnk)->expire_time) { if (LibAliasTime - (*lnk)->timestamp > (*lnk)->expire.timeout) {
DeleteLink(lnk); DeleteLink(lnk);
if ((*lnk) == NULL) if ((*lnk) == NULL)
return; return;
} }
/* move to end, swap may fail on a single entry list */ /* move to end, swap may fail on a single entry list */
TAILQ_REMOVE(&la->checkExpire, (*lnk), list_expire); TAILQ_REMOVE(&la->checkExpire, (*lnk), expire.list);
TAILQ_INSERT_TAIL(&la->checkExpire, (*lnk), list_expire); TAILQ_INSERT_TAIL(&la->checkExpire, (*lnk), expire.list);
} }
static struct alias_link *
UseLink(struct libalias *la, struct alias_link *lnk)
{
CleanupLink(la, &lnk);
if (lnk != NULL)
lnk->timestamp = LibAliasTime;
return (lnk);
}
static void static void
DeleteLink(struct alias_link **plnk) DeleteLink(struct alias_link **plnk)
{ {
struct alias_link *lnk = *plnk; struct alias_link *lnk = *plnk;
struct libalias *la = lnk->la; struct libalias *la = lnk->la;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* Don't do anything if the link is marked permanent */ /* Don't do anything if the link is marked permanent */
if (la->deleteAllLinks == 0 && lnk->flags & LINK_PERMANENT) if (la->deleteAllLinks == 0 && lnk->flags & LINK_PERMANENT)
return; return;
#ifndef NO_FW_PUNCH #ifndef NO_FW_PUNCH
/* Delete associated firewall hole, if any */ /* Delete associated firewall hole, if any */
ClearFWHole(lnk); ClearFWHole(lnk);
#endif #endif
switch (lnk->link_type) {
case LINK_PPTP:
LIST_REMOVE(lnk, pptp.list);
break;
default:
/* Free memory allocated for LSNAT server pool */ /* Free memory allocated for LSNAT server pool */
if (lnk->server != NULL) { if (lnk->server != NULL) {
struct server *head, *curr, *next; struct server *head, *curr, *next;
head = curr = lnk->server; head = curr = lnk->server;
do { do {
next = curr->next; next = curr->next;
free(curr); free(curr);
} while ((curr = next) != head); } while ((curr = next) != head);
} } else {
/* Adjust output table pointers */ /* Adjust output table pointers */
LIST_REMOVE(lnk, list_out); LIST_REMOVE(lnk, all.out);
}
/* Adjust input table pointers */ /* Adjust input table pointers */
LIST_REMOVE(lnk, list_in); LIST_REMOVE(lnk, all.in);
break;
}
/* remove from housekeeping */ /* remove from housekeeping */
TAILQ_REMOVE(&la->checkExpire, lnk, list_expire); TAILQ_REMOVE(&la->checkExpire, lnk, expire.list);
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
/* Close socket, if one has been allocated */ /* Close socket, if one has been allocated */
if (lnk->sockfd != -1) { if (lnk->sockfd != -1) {
la->sockCount--; la->sockCount--;
close(lnk->sockfd); close(lnk->sockfd);
} }
#endif #endif
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
AddLink(struct libalias *la, struct in_addr src_addr, struct in_addr dst_addr, AddLink(struct libalias *la, struct in_addr src_addr, struct in_addr dst_addr,
struct in_addr alias_addr, u_short src_port, u_short dst_port, struct in_addr alias_addr, u_short src_port, u_short dst_port,
int alias_port_param, int link_type) int alias_port_param, int link_type)
{ {
u_int start_point; u_int start_point;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = malloc(sizeof(struct alias_link)); lnk = malloc(sizeof(struct alias_link));
if (lnk != NULL) { if (lnk == NULL) {
#ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink(): ");
fprintf(stderr, "malloc() call failed.\n");
#endif
return (NULL);
}
/* Basic initialization */ /* Basic initialization */
lnk->la = la; lnk->la = la;
lnk->src_addr = src_addr; lnk->src_addr = src_addr;
lnk->dst_addr = dst_addr; lnk->dst_addr = dst_addr;
lnk->alias_addr = alias_addr; lnk->alias_addr = alias_addr;
lnk->proxy_addr.s_addr = INADDR_ANY; lnk->proxy_addr.s_addr = INADDR_ANY;
lnk->src_port = src_port; lnk->src_port = src_port;
lnk->dst_port = dst_port; lnk->dst_port = dst_port;
lnk->proxy_port = 0; lnk->proxy_port = 0;
lnk->server = NULL; lnk->server = NULL;
lnk->link_type = link_type; lnk->link_type = link_type;
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
lnk->sockfd = -1; lnk->sockfd = -1;
#endif #endif
lnk->flags = 0; lnk->flags = 0;
lnk->pflags = 0; lnk->pflags = 0;
lnk->timestamp = LibAliasTime; lnk->timestamp = LibAliasTime;
/* Expiration time */ /* Expiration time */
switch (link_type) { switch (link_type) {
case LINK_ICMP: case LINK_ICMP:
lnk->expire_time = ICMP_EXPIRE_TIME; lnk->expire.timeout = ICMP_EXPIRE_TIME;
break; break;
case LINK_UDP: case LINK_UDP:
lnk->expire_time = UDP_EXPIRE_TIME; lnk->expire.timeout = UDP_EXPIRE_TIME;
break; break;
case LINK_TCP: case LINK_TCP:
lnk->expire_time = TCP_EXPIRE_INITIAL; lnk->expire.timeout = TCP_EXPIRE_INITIAL;
break; break;
case LINK_PPTP:
lnk->flags |= LINK_PERMANENT; /* no timeout. */
break;
case LINK_FRAGMENT_ID: case LINK_FRAGMENT_ID:
lnk->expire_time = FRAGMENT_ID_EXPIRE_TIME; lnk->expire.timeout = FRAGMENT_ID_EXPIRE_TIME;
break; break;
case LINK_FRAGMENT_PTR: case LINK_FRAGMENT_PTR:
lnk->expire_time = FRAGMENT_PTR_EXPIRE_TIME; lnk->expire.timeout = FRAGMENT_PTR_EXPIRE_TIME;
break; break;
case LINK_ADDR: case LINK_ADDR:
break; break;
default: default:
lnk->expire_time = PROTO_EXPIRE_TIME; lnk->expire.timeout = PROTO_EXPIRE_TIME;
break; break;
} }
/* Determine alias flags */ /* Determine alias flags */
if (dst_addr.s_addr == INADDR_ANY) if (dst_addr.s_addr == INADDR_ANY)
lnk->flags |= LINK_UNKNOWN_DEST_ADDR; lnk->flags |= LINK_UNKNOWN_DEST_ADDR;
if (dst_port == 0) if (dst_port == 0)
lnk->flags |= LINK_UNKNOWN_DEST_PORT; lnk->flags |= LINK_UNKNOWN_DEST_PORT;
/* Determine alias port */ /* Determine alias port */
if (GetNewPort(la, lnk, alias_port_param) != 0) { if (GetNewPort(la, lnk, alias_port_param) != 0) {
free(lnk); free(lnk);
return (NULL); return (NULL);
} }
/* Link-type dependent initialization */ /* Link-type dependent initialization */
switch (link_type) { switch (link_type) {
struct tcp_dat *aux_tcp;
case LINK_ICMP: case LINK_ICMP:
la->icmpLinkCount++; la->icmpLinkCount++;
break; break;
case LINK_UDP: case LINK_UDP:
la->udpLinkCount++; la->udpLinkCount++;
break; break;
case LINK_TCP: case LINK_TCP: {
struct tcp_dat *aux_tcp;
int i;
aux_tcp = malloc(sizeof(struct tcp_dat)); aux_tcp = malloc(sizeof(struct tcp_dat));
if (aux_tcp != NULL) { if (aux_tcp != NULL) {
int i; #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink: ");
fprintf(stderr, " cannot allocate auxiliary TCP data\n");
#endif
free(lnk);
return (NULL);
}
la->tcpLinkCount++; la->tcpLinkCount++;
aux_tcp->state.in = ALIAS_TCP_STATE_NOT_CONNECTED; aux_tcp->state.in = ALIAS_TCP_STATE_NOT_CONNECTED;
aux_tcp->state.out = ALIAS_TCP_STATE_NOT_CONNECTED; aux_tcp->state.out = ALIAS_TCP_STATE_NOT_CONNECTED;
aux_tcp->state.index = 0; aux_tcp->state.index = 0;
aux_tcp->state.ack_modified = 0; aux_tcp->state.ack_modified = 0;
for (i = 0; i < N_LINK_TCP_DATA; i++) for (i = 0; i < N_LINK_TCP_DATA; i++)
aux_tcp->ack[i].active = 0; aux_tcp->ack[i].active = 0;
aux_tcp->fwhole = -1; aux_tcp->fwhole = -1;
lnk->data.tcp = aux_tcp; lnk->data.tcp = aux_tcp;
} else {
#ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink: ");
fprintf(stderr, " cannot allocate auxiliary TCP data\n");
#endif
free(lnk);
return (NULL);
} }
break; break;
case LINK_PPTP: case LINK_PPTP:
la->pptpLinkCount++; la->pptpLinkCount++;
break; break;
case LINK_FRAGMENT_ID: case LINK_FRAGMENT_ID:
la->fragmentIdLinkCount++; la->fragmentIdLinkCount++;
break; break;
case LINK_FRAGMENT_PTR: case LINK_FRAGMENT_PTR:
la->fragmentPtrLinkCount++; la->fragmentPtrLinkCount++;
break; break;
case LINK_ADDR: case LINK_ADDR:
break; break;
default: default:
la->protoLinkCount++; la->protoLinkCount++;
break; break;
} }
switch (link_type) {
case LINK_PPTP:
LIST_INSERT_HEAD(&la->pptpTable, lnk, pptp.list);
break;
default: {
struct group_in *grp;
grp = StartPointIn(la, alias_addr, lnk->alias_port, link_type, 1);
if (grp == NULL) {
free(lnk);
return (NULL);
}
/* Set up pointers for output lookup table */ /* Set up pointers for output lookup table */
start_point = StartPointOut(src_addr, dst_addr, start_point = StartPointOut(src_addr, dst_addr,
src_port, dst_port, link_type); src_port, dst_port, link_type);
LIST_INSERT_HEAD(&la->linkTableOut[start_point], lnk, list_out); LIST_INSERT_HEAD(&la->linkTableOut[start_point], lnk, all.out);
/* Set up pointers for input lookup table */ /* Set up pointers for input lookup table */
start_point = StartPointIn(alias_addr, lnk->alias_port, link_type); if (lnk->flags & LINK_PARTIALLY_SPECIFIED)
LIST_INSERT_HEAD(&la->linkTableIn[start_point], lnk, list_in); LIST_INSERT_HEAD(&grp->partial, lnk, all.in);
else
LIST_INSERT_HEAD(&grp->full, lnk, all.in);
}
break;
}
/* Include the element into the housekeeping list */ /* Include the element into the housekeeping list */
TAILQ_INSERT_TAIL(&la->checkExpire, lnk, list_expire); TAILQ_INSERT_TAIL(&la->checkExpire, lnk, expire.list);
} else {
#ifdef LIBALIAS_DEBUG if (la->packetAliasMode & PKT_ALIAS_LOG)
fprintf(stderr, "PacketAlias/AddLink(): ");
fprintf(stderr, "malloc() call failed.\n");
#endif
}
if (la->packetAliasMode & PKT_ALIAS_LOG) {
ShowAliasStats(la); ShowAliasStats(la);
}
return (lnk); return (lnk);
} }
/* /*
* If alias_port_param is less than zero, alias port will be automatically * If alias_port_param is less than zero, alias port will be automatically
* chosen. If greater than zero, equal to alias port * chosen. If greater than zero, equal to alias port
*/ */
static struct alias_link * static struct alias_link *
Show All 19 Lines if (new_lnk != NULL &&
old_lnk->data.tcp->fwhole > 0) { old_lnk->data.tcp->fwhole > 0) {
PunchFWHole(new_lnk); PunchFWHole(new_lnk);
} }
#endif #endif
DeleteLink(&old_lnk); DeleteLink(&old_lnk);
return (new_lnk); return (new_lnk);
} }
#define OUTGUARD \
if (lnk->src_port != src_port || \
lnk->src_addr.s_addr != src_addr.s_addr || \
lnk->dst_addr.s_addr != dst_addr.s_addr || \
lnk->dst_port != dst_port || \
lnk->link_type != link_type) \
continue;
static struct alias_link * static struct alias_link *
_SearchLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr,
u_short src_port,
u_short dst_port,
int link_type) {
u_int i;
struct alias_link *lnk;
i = StartPointOut(src_addr, dst_addr, src_port, dst_port, link_type);
LIST_FOREACH(lnk, &la->linkTableOut[i], all.out) {
OUTGUARD;
return (UseLink(la, lnk));
}
return (NULL);
}
#undef OUTGUARD
static struct alias_link *
_FindLinkOut(struct libalias *la, struct in_addr src_addr, _FindLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
int link_type, int link_type,
int replace_partial_links) int replace_partial_links)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, src_port, dst_port, link_type); lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, dst_port, link_type);
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) { if (lnk != NULL || !replace_partial_links)
if (lnk->dst_addr.s_addr == dst_addr.s_addr && return (lnk);
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->src_port == src_port &&
lnk->dst_port == dst_port &&
lnk->link_type == link_type &&
lnk->server == NULL)
break;
}
CleanupLink(la, &lnk);
if (lnk != NULL)
lnk->timestamp = LibAliasTime;
/* Search for partially specified links. */ /* Search for partially specified links. */
if (lnk == NULL && replace_partial_links) {
if (dst_port != 0 && dst_addr.s_addr != INADDR_ANY) { if (dst_port != 0 && dst_addr.s_addr != INADDR_ANY) {
lnk = _FindLinkOut(la, src_addr, dst_addr, src_port, 0, lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, 0,
link_type, 0); link_type);
if (lnk == NULL) if (lnk == NULL)
lnk = _FindLinkOut(la, src_addr, NO_ADDR, src_port, lnk = _SearchLinkOut(la, src_addr, ANY_ADDR, src_port,
dst_port, link_type, 0); dst_port, link_type);
} }
if (lnk == NULL && if (lnk == NULL &&
(dst_port != 0 || dst_addr.s_addr != INADDR_ANY)) { (dst_port != 0 || dst_addr.s_addr != INADDR_ANY)) {
lnk = _FindLinkOut(la, src_addr, NO_ADDR, src_port, 0, lnk = _SearchLinkOut(la, src_addr, ANY_ADDR, src_port, 0,
link_type, 0); link_type);
} }
if (lnk != NULL) { if (lnk != NULL) {
lnk = ReLink(lnk, lnk = ReLink(lnk,
src_addr, dst_addr, lnk->alias_addr, src_addr, dst_addr, lnk->alias_addr,
src_port, dst_port, lnk->alias_port, src_port, dst_port, lnk->alias_port,
link_type); link_type);
} }
}
return (lnk); return (lnk);
} }
static struct alias_link * static struct alias_link *
FindLinkOut(struct libalias *la, struct in_addr src_addr, FindLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
Show All 10 Lines if (lnk == NULL) {
/* /*
* The following allows permanent links to be specified as * The following allows permanent links to be specified as
* using the default source address (i.e. device interface * using the default source address (i.e. device interface
* address) without knowing in advance what that address * address) without knowing in advance what that address
* is. * is.
*/ */
if (la->aliasAddress.s_addr != INADDR_ANY && if (la->aliasAddress.s_addr != INADDR_ANY &&
src_addr.s_addr == la->aliasAddress.s_addr) { src_addr.s_addr == la->aliasAddress.s_addr) {
lnk = _FindLinkOut(la, NO_ADDR, dst_addr, src_port, dst_port, lnk = _FindLinkOut(la, ANY_ADDR, dst_addr, src_port, dst_port,
link_type, replace_partial_links); link_type, replace_partial_links);
} }
} }
return (lnk); return (lnk);
} }
static struct alias_link * static struct alias_link *
_FindLinkIn(struct libalias *la, struct in_addr dst_addr, _FindLinkIn(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_short dst_port, u_short dst_port,
u_short alias_port, u_short alias_port,
int link_type, int link_type,
int replace_partial_links) int replace_partial_links)
{ {
int flags_in; int flags_in;
u_int start_point; struct group_in *grp;
struct alias_link *lnk; struct alias_link *lnk;
struct alias_link *lnk_fully_specified;
struct alias_link *lnk_unknown_all; struct alias_link *lnk_unknown_all;
struct alias_link *lnk_unknown_dst_addr; struct alias_link *lnk_unknown_dst_addr;
struct alias_link *lnk_unknown_dst_port; struct alias_link *lnk_unknown_dst_port;
struct in_addr src_addr;
u_short src_port;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* Initialize pointers */ /* Initialize pointers */
lnk_fully_specified = NULL;
lnk_unknown_all = NULL; lnk_unknown_all = NULL;
lnk_unknown_dst_addr = NULL; lnk_unknown_dst_addr = NULL;
lnk_unknown_dst_port = NULL; lnk_unknown_dst_port = NULL;
/* If either the dest addr or port is unknown, the search /* If either the dest addr or port is unknown, the search
* loop will have to know about this. */ * loop will have to know about this. */
flags_in = 0; flags_in = 0;
if (dst_addr.s_addr == INADDR_ANY) if (dst_addr.s_addr == INADDR_ANY)
flags_in |= LINK_UNKNOWN_DEST_ADDR; flags_in |= LINK_UNKNOWN_DEST_ADDR;
if (dst_port == 0) if (dst_port == 0)
flags_in |= LINK_UNKNOWN_DEST_PORT; flags_in |= LINK_UNKNOWN_DEST_PORT;
/* Search loop */ /* Search loop */
start_point = StartPointIn(alias_addr, alias_port, link_type); grp = StartPointIn(la, alias_addr, alias_port, link_type, 0);
LIST_FOREACH(lnk, &la->linkTableIn[start_point], list_in) { if (grp == NULL)
int flags; return (NULL);
flags = flags_in | lnk->flags; switch (flags_in) {
if (!(flags & LINK_PARTIALLY_SPECIFIED)) { case 0:
if (lnk->alias_addr.s_addr == alias_addr.s_addr LIST_FOREACH(lnk, &grp->full, all.in) {
&& lnk->alias_port == alias_port if (lnk->dst_addr.s_addr == dst_addr.s_addr &&
&& lnk->dst_addr.s_addr == dst_addr.s_addr lnk->dst_port == dst_port)
&& lnk->dst_port == dst_port return (UseLink(la, lnk));
&& lnk->link_type == link_type) { }
lnk_fully_specified = lnk;
break; break;
case LINK_UNKNOWN_DEST_PORT:
LIST_FOREACH(lnk, &grp->full, all.in) {
if(lnk->dst_addr.s_addr == dst_addr.s_addr) {
lnk_unknown_dst_port = lnk;
break;
} }
} else if ((flags & LINK_UNKNOWN_DEST_ADDR)
&& (flags & LINK_UNKNOWN_DEST_PORT)) {
if (lnk->alias_addr.s_addr == alias_addr.s_addr
&& lnk->alias_port == alias_port
&& lnk->link_type == link_type) {
if (lnk_unknown_all == NULL)
lnk_unknown_all = lnk;
} }
} else if (flags & LINK_UNKNOWN_DEST_ADDR) { break;
if (lnk->alias_addr.s_addr == alias_addr.s_addr case LINK_UNKNOWN_DEST_ADDR:
&& lnk->alias_port == alias_port LIST_FOREACH(lnk, &grp->full, all.in) {
&& lnk->link_type == link_type if(lnk->dst_port == dst_port) {
&& lnk->dst_port == dst_port) {
if (lnk_unknown_dst_addr == NULL)
lnk_unknown_dst_addr = lnk; lnk_unknown_dst_addr = lnk;
break;
} }
} else if (flags & LINK_UNKNOWN_DEST_PORT) { }
if (lnk->alias_addr.s_addr == alias_addr.s_addr break;
&& lnk->alias_port == alias_port case LINK_PARTIALLY_SPECIFIED:
&& lnk->link_type == link_type lnk_unknown_all = LIST_FIRST(&grp->full);
&& lnk->dst_addr.s_addr == dst_addr.s_addr) { break;
if (lnk_unknown_dst_port == NULL) }
if (lnk_unknown_dst_port == NULL) {
LIST_FOREACH(lnk, &grp->partial, all.in) {
int flags = (flags_in | lnk->flags) & LINK_PARTIALLY_SPECIFIED;
if (flags == LINK_PARTIALLY_SPECIFIED &&
lnk_unknown_all == NULL)
lnk_unknown_all = lnk;
if (flags == LINK_UNKNOWN_DEST_ADDR &&
lnk->dst_port == dst_port &&
lnk_unknown_dst_addr == NULL)
lnk_unknown_dst_addr = lnk;
if (flags == LINK_UNKNOWN_DEST_PORT &&
lnk->dst_addr.s_addr == dst_addr.s_addr) {
lnk_unknown_dst_port = lnk; lnk_unknown_dst_port = lnk;
break;
} }
} }
} }
CleanupLink(la, &lnk_fully_specified); lnk = (lnk_unknown_dst_port != NULL) ? lnk_unknown_dst_port
if (lnk_fully_specified != NULL) { : (lnk_unknown_dst_addr != NULL) ? lnk_unknown_dst_addr
lnk_fully_specified->timestamp = LibAliasTime; : lnk_unknown_all;
lnk = lnk_fully_specified;
} else if (lnk_unknown_dst_port != NULL)
lnk = lnk_unknown_dst_port;
else if (lnk_unknown_dst_addr != NULL)
lnk = lnk_unknown_dst_addr;
else if (lnk_unknown_all != NULL)
lnk = lnk_unknown_all;
else
return (NULL);
if (replace_partial_links && if (lnk == NULL || !replace_partial_links)
(lnk->flags & LINK_PARTIALLY_SPECIFIED || lnk->server != NULL)) { return (lnk);
struct in_addr src_addr;
u_short src_port;
if (lnk->server != NULL) { /* LSNAT link */ if (lnk->server != NULL) { /* LSNAT link */
src_addr = lnk->server->addr; src_addr = lnk->server->addr;
src_port = lnk->server->port; src_port = lnk->server->port;
lnk->server = lnk->server->next; lnk->server = lnk->server->next;
} else { } else {
src_addr = lnk->src_addr; src_addr = lnk->src_addr;
src_port = lnk->src_port; src_port = lnk->src_port;
} }
if (link_type == LINK_SCTP) { if (link_type == LINK_SCTP) {
lnk->src_addr = src_addr; lnk->src_addr = src_addr;
lnk->src_port = src_port; lnk->src_port = src_port;
return (lnk); } else {
}
lnk = ReLink(lnk, lnk = ReLink(lnk,
src_addr, dst_addr, alias_addr, src_addr, dst_addr, alias_addr,
src_port, dst_port, alias_port, src_port, dst_port, alias_port,
link_type); link_type);
} }
return (lnk); return (lnk);
} }
Show All 15 Lines if (lnk == NULL) {
/* /*
* The following allows permanent links to be specified as * The following allows permanent links to be specified as
* using the default aliasing address (i.e. device * using the default aliasing address (i.e. device
* interface address) without knowing in advance what that * interface address) without knowing in advance what that
* address is. * address is.
*/ */
if (la->aliasAddress.s_addr != INADDR_ANY && if (la->aliasAddress.s_addr != INADDR_ANY &&
alias_addr.s_addr == la->aliasAddress.s_addr) { alias_addr.s_addr == la->aliasAddress.s_addr) {
lnk = _FindLinkIn(la, dst_addr, NO_ADDR, dst_port, alias_port, lnk = _FindLinkIn(la, dst_addr, ANY_ADDR, dst_port, alias_port,
link_type, replace_partial_links); link_type, replace_partial_links);
} }
} }
return (lnk); return (lnk);
} }
/* External routines for finding/adding links /* External routines for finding/adding links
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 LinesFindFragmentIn1(struct libalias *la, struct in_addr dst_addr,
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, dst_addr, alias_addr, lnk = FindLinkIn(la, dst_addr, alias_addr,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID, 0); LINK_FRAGMENT_ID, 0);
if (lnk == NULL) { if (lnk == NULL) {
lnk = AddLink(la, NO_ADDR, dst_addr, alias_addr, lnk = AddLink(la, ANY_ADDR, dst_addr, alias_addr,
NO_SRC_PORT, NO_DEST_PORT, ip_id, NO_SRC_PORT, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID); LINK_FRAGMENT_ID);
} }
return (lnk); return (lnk);
} }
/* Doesn't add a link if one is not found. */ /* Doesn't add a link if one is not found. */
struct alias_link * struct alias_link *
FindFragmentIn2(struct libalias *la, struct in_addr dst_addr, FindFragmentIn2(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, u_short ip_id) struct in_addr alias_addr, u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return FindLinkIn(la, dst_addr, alias_addr, return FindLinkIn(la, dst_addr, alias_addr,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID, 0); LINK_FRAGMENT_ID, 0);
} }
struct alias_link * struct alias_link *
AddFragmentPtrLink(struct libalias *la, struct in_addr dst_addr, AddFragmentPtrLink(struct libalias *la, struct in_addr dst_addr,
u_short ip_id) u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return AddLink(la, NO_ADDR, dst_addr, NO_ADDR, return AddLink(la, ANY_ADDR, dst_addr, ANY_ADDR,
NO_SRC_PORT, NO_DEST_PORT, ip_id, NO_SRC_PORT, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_PTR); LINK_FRAGMENT_PTR);
} }
struct alias_link * struct alias_link *
FindFragmentPtr(struct libalias *la, struct in_addr dst_addr, FindFragmentPtr(struct libalias *la, struct in_addr dst_addr,
u_short ip_id) u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return FindLinkIn(la, dst_addr, NO_ADDR, return FindLinkIn(la, dst_addr, ANY_ADDR,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_PTR, 0); LINK_FRAGMENT_PTR, 0);
} }
struct alias_link * struct alias_link *
FindProtoIn(struct libalias *la, struct in_addr dst_addr, FindProtoIn(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_char proto) u_char proto)
▲ Show 20 Lines • Show All 131 Lines • ▼ Show 20 LinesAddPptp(struct libalias *la, struct in_addr src_addr,
return (lnk); return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpOutByCallId(struct libalias *la, struct in_addr src_addr, FindPptpOutByCallId(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_int16_t src_call_id) u_int16_t src_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, 0, 0, LINK_PPTP); LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) if (lnk->src_addr.s_addr == src_addr.s_addr &&
if (lnk->link_type == LINK_PPTP &&
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->src_port == src_call_id) lnk->src_port == src_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpOutByPeerCallId(struct libalias *la, struct in_addr src_addr, FindPptpOutByPeerCallId(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_int16_t dst_call_id) u_int16_t dst_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, 0, 0, LINK_PPTP); LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) if (lnk->src_addr.s_addr == src_addr.s_addr &&
if (lnk->link_type == LINK_PPTP &&
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->dst_port == dst_call_id) lnk->dst_port == dst_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpInByCallId(struct libalias *la, struct in_addr dst_addr, FindPptpInByCallId(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_int16_t dst_call_id) u_int16_t dst_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointIn(alias_addr, 0, LINK_PPTP);
LIST_FOREACH(lnk, &la->linkTableIn[i], list_in) LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
if (lnk->link_type == LINK_PPTP && if (lnk->dst_port == dst_call_id &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->alias_addr.s_addr == alias_addr.s_addr && lnk->alias_addr.s_addr == alias_addr.s_addr)
lnk->dst_port == dst_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpInByPeerCallId(struct libalias *la, struct in_addr dst_addr, FindPptpInByPeerCallId(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_int16_t alias_call_id) u_int16_t alias_call_id)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, dst_addr, alias_addr, LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
0 /* any */ , alias_call_id, if (lnk->alias_port == alias_call_id &&
LINK_PPTP, 0); lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->alias_addr.s_addr == alias_addr.s_addr)
break;
return (lnk); return (lnk);
} }
struct alias_link * struct alias_link *
FindRtspOut(struct libalias *la, struct in_addr src_addr, FindRtspOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
Show All 30 Lines
} }
struct in_addr struct in_addr
FindOriginalAddress(struct libalias *la, struct in_addr alias_addr) FindOriginalAddress(struct libalias *la, struct in_addr alias_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, NO_ADDR, alias_addr, lnk = FindLinkIn(la, ANY_ADDR, alias_addr,
0, 0, LINK_ADDR, 0); 0, 0, LINK_ADDR, 0);
if (lnk == NULL) { if (lnk == NULL) {
la->newDefaultLink = 1; la->newDefaultLink = 1;
if (la->targetAddress.s_addr == INADDR_ANY) if (la->targetAddress.s_addr == INADDR_ANY)
return (alias_addr); return (alias_addr);
else if (la->targetAddress.s_addr == INADDR_NONE) else if (la->targetAddress.s_addr == INADDR_NONE)
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : alias_addr; la->aliasAddress : alias_addr;
Show All 15 Lines
} }
struct in_addr struct in_addr
FindAliasAddress(struct libalias *la, struct in_addr original_addr) FindAliasAddress(struct libalias *la, struct in_addr original_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkOut(la, original_addr, NO_ADDR, lnk = FindLinkOut(la, original_addr, ANY_ADDR,
0, 0, LINK_ADDR, 0); 0, 0, LINK_ADDR, 0);
if (lnk == NULL) { if (lnk == NULL) {
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : original_addr; la->aliasAddress : original_addr;
} else { } else {
if (lnk->alias_addr.s_addr == INADDR_ANY) if (lnk->alias_addr.s_addr == INADDR_ANY)
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : original_addr; la->aliasAddress : original_addr;
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
void void
SetStateIn(struct alias_link *lnk, int state) SetStateIn(struct alias_link *lnk, int state)
{ {
/* TCP input state */ /* TCP input state */
switch (state) { switch (state) {
case ALIAS_TCP_STATE_DISCONNECTED: case ALIAS_TCP_STATE_DISCONNECTED:
if (lnk->data.tcp->state.out != ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.out != ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_DEAD; lnk->expire.timeout = TCP_EXPIRE_DEAD;
else else
lnk->expire_time = TCP_EXPIRE_SINGLEDEAD; lnk->expire.timeout = TCP_EXPIRE_SINGLEDEAD;
break; break;
case ALIAS_TCP_STATE_CONNECTED: case ALIAS_TCP_STATE_CONNECTED:
if (lnk->data.tcp->state.out == ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.out == ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_CONNECTED; lnk->expire.timeout = TCP_EXPIRE_CONNECTED;
break; break;
default: default:
#ifdef _KERNEL #ifdef _KERNEL
panic("libalias:SetStateIn() unknown state"); panic("libalias:SetStateIn() unknown state");
#else #else
abort(); abort();
#endif #endif
} }
lnk->data.tcp->state.in = state; lnk->data.tcp->state.in = state;
} }
void void
SetStateOut(struct alias_link *lnk, int state) SetStateOut(struct alias_link *lnk, int state)
{ {
/* TCP output state */ /* TCP output state */
switch (state) { switch (state) {
case ALIAS_TCP_STATE_DISCONNECTED: case ALIAS_TCP_STATE_DISCONNECTED:
if (lnk->data.tcp->state.in != ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.in != ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_DEAD; lnk->expire.timeout = TCP_EXPIRE_DEAD;
else else
lnk->expire_time = TCP_EXPIRE_SINGLEDEAD; lnk->expire.timeout = TCP_EXPIRE_SINGLEDEAD;
break; break;
case ALIAS_TCP_STATE_CONNECTED: case ALIAS_TCP_STATE_CONNECTED:
if (lnk->data.tcp->state.in == ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.in == ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_CONNECTED; lnk->expire.timeout = TCP_EXPIRE_CONNECTED;
break; break;
default: default:
#ifdef _KERNEL #ifdef _KERNEL
panic("libalias:SetStateOut() unknown state"); panic("libalias:SetStateOut() unknown state");
#else #else
abort(); abort();
#endif #endif
} }
▲ Show 20 Lines • Show All 232 Lines • ▼ Show 20 Lines
SetExpire(struct alias_link *lnk, int expire) SetExpire(struct alias_link *lnk, int expire)
{ {
if (expire == 0) { if (expire == 0) {
lnk->flags &= ~LINK_PERMANENT; lnk->flags &= ~LINK_PERMANENT;
DeleteLink(&lnk); DeleteLink(&lnk);
} else if (expire == -1) { } else if (expire == -1) {
lnk->flags |= LINK_PERMANENT; lnk->flags |= LINK_PERMANENT;
} else if (expire > 0) { } else if (expire > 0) {
lnk->expire_time = expire; lnk->expire.timeout = expire;
} else { } else {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/SetExpire(): "); fprintf(stderr, "PacketAlias/SetExpire(): ");
fprintf(stderr, "error in expire parameter\n"); fprintf(stderr, "error in expire parameter\n");
#endif #endif
} }
} }
▲ Show 20 Lines • Show All 187 Lines • ▼ Show 20 Lines
LibAliasAddServer(struct libalias *la, struct alias_link *lnk, struct in_addr addr, u_short port) LibAliasAddServer(struct libalias *la, struct alias_link *lnk, struct in_addr addr, u_short port)
{ {
struct server *server; struct server *server;
int res; int res;
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
(void)la; (void)la;
switch (lnk->link_type) {
case LINK_PPTP:
server = NULL;
break;
default:
server = malloc(sizeof(struct server)); server = malloc(sizeof(struct server));
break;
}
if (server != NULL) { if (server != NULL) {
struct server *head; struct server *head;
server->addr = addr; server->addr = addr;
server->port = port; server->port = port;
head = lnk->server; head = lnk->server;
if (head == NULL) if (head == NULL) {
server->next = server; server->next = server;
else { /* not usable for outgoing connections */
LIST_REMOVE(lnk, all.out);
} else {
struct server *s; struct server *s;
for (s = head; s->next != head; s = s->next) for (s = head; s->next != head; s = s->next)
; ;
s->next = server; s->next = server;
server->next = head; server->next = head;
} }
lnk->server = server; lnk->server = server;
Show All 37 Lines
/* Static address translation */ /* Static address translation */
struct alias_link * struct alias_link *
LibAliasRedirectAddr(struct libalias *la, struct in_addr src_addr, LibAliasRedirectAddr(struct libalias *la, struct in_addr src_addr,
struct in_addr alias_addr) struct in_addr alias_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
lnk = AddLink(la, src_addr, NO_ADDR, alias_addr, lnk = AddLink(la, src_addr, ANY_ADDR, alias_addr,
0, 0, 0, 0, 0, 0,
LINK_ADDR); LINK_ADDR);
if (lnk != NULL) { if (lnk != NULL) {
lnk->flags |= LINK_PERMANENT; lnk->flags |= LINK_PERMANENT;
} }
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
else { else {
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines#ifdef _KERNEL
LibAliasTime = time_uptime; LibAliasTime = time_uptime;
#else #else
LibAliasTime = time(NULL); LibAliasTime = time(NULL);
#endif #endif
for (i = 0; i < LINK_TABLE_OUT_SIZE; i++) for (i = 0; i < LINK_TABLE_OUT_SIZE; i++)
LIST_INIT(&la->linkTableOut[i]); LIST_INIT(&la->linkTableOut[i]);
for (i = 0; i < LINK_TABLE_IN_SIZE; i++) for (i = 0; i < LINK_TABLE_IN_SIZE; i++)
LIST_INIT(&la->linkTableIn[i]); LIST_INIT(&la->groupTableIn[i]);
LIST_INIT(&la->pptpTable);
TAILQ_INIT(&la->checkExpire); TAILQ_INIT(&la->checkExpire);
#ifdef _KERNEL #ifdef _KERNEL
AliasSctpInit(la); AliasSctpInit(la);
#endif #endif
LIBALIAS_LOCK_INIT(la); LIBALIAS_LOCK_INIT(la);
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
} else { } else {
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
la->deleteAllLinks = 1; la->deleteAllLinks = 1;
CleanupAliasData(la); CleanupAliasData(la);
la->deleteAllLinks = 0; la->deleteAllLinks = 0;
#ifdef _KERNEL #ifdef _KERNEL
AliasSctpTerm(la); AliasSctpTerm(la);
AliasSctpInit(la); AliasSctpInit(la);
#endif #endif
} }
la->aliasAddress.s_addr = INADDR_ANY; la->aliasAddress.s_addr = INADDR_ANY;
la->targetAddress.s_addr = INADDR_ANY; la->targetAddress.s_addr = INADDR_ANY;
la->aliasPortLower = 0x8000;
la->aliasPortLength = 0x8000;
la->icmpLinkCount = 0; la->icmpLinkCount = 0;
la->udpLinkCount = 0; la->udpLinkCount = 0;
la->tcpLinkCount = 0; la->tcpLinkCount = 0;
la->sctpLinkCount = 0; la->sctpLinkCount = 0;
la->pptpLinkCount = 0; la->pptpLinkCount = 0;
la->protoLinkCount = 0; la->protoLinkCount = 0;
la->fragmentIdLinkCount = 0; la->fragmentIdLinkCount = 0;
▲ Show 20 Lines • Show All 380 Lines • Show Last 20 Lines
View Options

multimedia/libxine/files/

Show First 20 Lines • Show All 214 Lines • ▼ Show 20 Lines
/* Dummy port number codes used for FindLinkIn/Out() and AddLink(). /* Dummy port number codes used for FindLinkIn/Out() and AddLink().
These constants can be anything except zero, which indicates an These constants can be anything except zero, which indicates an
unknown port number. */ unknown port number. */
#define NO_DEST_PORT 1 #define NO_DEST_PORT 1
#define NO_SRC_PORT 1 #define NO_SRC_PORT 1
/* Dummy address used for FindLinkIn/Out() and AddLink(). /* Matches any/unknown address in FindLinkIn/Out() and AddLink(). */
The value of this variable is never used. */ static struct in_addr const ANY_ADDR = { INADDR_ANY };
static struct in_addr const NO_ADDR;
/* Data Structures /* Data Structures
The fundamental data structure used in this program is The fundamental data structure used in this program is
"struct alias_link". Whenever a TCP connection is made, "struct alias_link". Whenever a TCP connection is made,
a UDP datagram is sent out, or an ICMP echo request is made, a UDP datagram is sent out, or an ICMP echo request is made,
a link record is made (if it has not already been created). a link record is made (if it has not already been created).
The link record is identified by the source address/port The link record is identified by the source address/port
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
/* flag bits */ /* flag bits */
#define LINK_UNKNOWN_DEST_PORT 0x01 #define LINK_UNKNOWN_DEST_PORT 0x01
#define LINK_UNKNOWN_DEST_ADDR 0x02 #define LINK_UNKNOWN_DEST_ADDR 0x02
#define LINK_PERMANENT 0x04 #define LINK_PERMANENT 0x04
#define LINK_PARTIALLY_SPECIFIED 0x03 /* logical-or of first two bits */ #define LINK_PARTIALLY_SPECIFIED 0x03 /* logical-or of first two bits */
#define LINK_UNFIREWALLED 0x08 #define LINK_UNFIREWALLED 0x08
int timestamp; /* Time link was last accessed */ int timestamp; /* Time link was last accessed */
int expire_time; /* Expire time for link */
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
int sockfd; /* socket descriptor */ int sockfd; /* socket descriptor */
#endif #endif
/* Linked list of pointers for input and output lookup tables */ /* Linked list of pointers for input and output lookup tables */
LIST_ENTRY (alias_link) list_out; union {
LIST_ENTRY (alias_link) list_in; struct {
TAILQ_ENTRY (alias_link) list_expire; LIST_ENTRY(alias_link) in;
LIST_ENTRY(alias_link) out;
} all;
struct {
LIST_ENTRY(alias_link) list;
} pptp;
};
struct {
TAILQ_ENTRY(alias_link) list;
int timeout; /* Expire time for link */
} expire;
/* Auxiliary data */ /* Auxiliary data */
union { union {
char *frag_ptr; char *frag_ptr;
struct in_addr frag_addr; struct in_addr frag_addr;
struct tcp_dat *tcp; struct tcp_dat *tcp;
} data; } data;
}; };
Show All 36 Lines StartPointOut() -- link table initial search point for
outgoing packets outgoing packets
Miscellaneous: Miscellaneous:
SeqDiff() -- difference between two TCP sequences SeqDiff() -- difference between two TCP sequences
ShowAliasStats() -- send alias statistics to a monitor file ShowAliasStats() -- send alias statistics to a monitor file
*/ */
/* Local prototypes */ /* Local prototypes */
static u_int StartPointIn(struct in_addr, u_short, int); static struct group_in *
StartPointIn(struct libalias *, struct in_addr, u_short, int, int);
static u_int static u_int
StartPointOut(struct in_addr, struct in_addr, StartPointOut(struct in_addr, struct in_addr, u_short, u_short, int);
u_short, u_short, int);
static int SeqDiff(u_long, u_long); static int SeqDiff(u_long, u_long);
#ifndef NO_FW_PUNCH #ifndef NO_FW_PUNCH
/* Firewall control */ /* Firewall control */
static void InitPunchFW(struct libalias *); static void InitPunchFW(struct libalias *);
static void UninitPunchFW(struct libalias *); static void UninitPunchFW(struct libalias *);
static void ClearFWHole(struct alias_link *); static void ClearFWHole(struct alias_link *);
#endif #endif
/* Log file control */ /* Log file control */
static void ShowAliasStats(struct libalias *); static void ShowAliasStats(struct libalias *);
static int InitPacketAliasLog(struct libalias *); static int InitPacketAliasLog(struct libalias *);
static void UninitPacketAliasLog(struct libalias *); static void UninitPacketAliasLog(struct libalias *);
void SctpShowAliasStats(struct libalias *la); void SctpShowAliasStats(struct libalias *la);
static u_int #define INGUARD \
StartPointIn(struct in_addr alias_addr, if (grp->alias_port != alias_port || \
u_short alias_port, grp->link_type != link_type || \
int link_type) grp->alias_addr.s_addr != alias_addr.s_addr) \
continue;
static struct group_in *
StartPointIn(struct libalias *la,
struct in_addr alias_addr, u_short alias_port, int link_type,
int create)
{ {
u_int n; u_int n;
struct group_in *grp, *tmp;
n = alias_addr.s_addr; n = alias_addr.s_addr;
if (link_type != LINK_PPTP)
n += alias_port; n += alias_port;
n += link_type; n += link_type;
return (n % LINK_TABLE_IN_SIZE); n %= LINK_TABLE_IN_SIZE;
LIST_FOREACH_SAFE(grp, &la->groupTableIn[n], group_in, tmp) {
/* Auto cleanup */
if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {
LIST_REMOVE(grp, group_in);
free(grp);
} else {
INGUARD;
return (grp);
} }
}
if (!create || (grp = malloc(sizeof(*grp))) == NULL)
return (grp);
grp->alias_addr = alias_addr;
grp->alias_port = alias_port;
grp->link_type = link_type;
LIST_INIT(&grp->full);
LIST_INIT(&grp->partial);
LIST_INSERT_HEAD(&la->groupTableIn[n], grp, group_in);
return (grp);
}
#undef INGUARD
static u_int static u_int
StartPointOut(struct in_addr src_addr, struct in_addr dst_addr, StartPointOut(struct in_addr src_addr, struct in_addr dst_addr,
u_short src_port, u_short dst_port, int link_type) u_short src_port, u_short dst_port, int link_type)
{ {
u_int n; u_int n;
n = src_addr.s_addr; n = src_addr.s_addr;
n += dst_addr.s_addr; n += dst_addr.s_addr;
if (link_type != LINK_PPTP) {
n += src_port; n += src_port;
n += dst_port; n += dst_port;
}
n += link_type; n += link_type;
return (n % LINK_TABLE_OUT_SIZE); return (n % LINK_TABLE_OUT_SIZE);
} }
static int static int
SeqDiff(u_long x, u_long y) SeqDiff(u_long x, u_long y)
{ {
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
/* Local prototypes */ /* Local prototypes */
static int GetNewPort(struct libalias *, struct alias_link *, int); static int GetNewPort(struct libalias *, struct alias_link *, int);
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
static u_short GetSocket(struct libalias *, u_short, int *, int); static u_short GetSocket(struct libalias *, u_short, int *, int);
#endif #endif
static void CleanupAliasData(struct libalias *); static void CleanupAliasData(struct libalias *);
static void CleanupLink(struct libalias *, struct alias_link **); static void CleanupLink(struct libalias *, struct alias_link **);
static void DeleteLink(struct alias_link **); static void DeleteLink(struct alias_link **);
static struct alias_link *
UseLink(struct libalias *, struct alias_link *);
static struct alias_link * static struct alias_link *
ReLink(struct alias_link *, ReLink(struct alias_link *,
struct in_addr, struct in_addr, struct in_addr, struct in_addr, struct in_addr, struct in_addr,
u_short, u_short, int, int); u_short, u_short, int, int);
static struct alias_link * static struct alias_link *
FindLinkOut(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int); FindLinkOut(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int);
static struct alias_link * static struct alias_link *
FindLinkIn(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int); FindLinkIn(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int);
#define ALIAS_PORT_BASE 0x08000 static u_short _RandomPort(struct libalias *la);
#define ALIAS_PORT_MASK 0x07fff
#define ALIAS_PORT_MASK_EVEN 0x07ffe
#define GET_NEW_PORT_MAX_ATTEMPTS 20 #define GET_NEW_PORT_MAX_ATTEMPTS 20
#define FIND_EVEN_ALIAS_BASE 1 /* get random port in network byte order */
static u_short
_RandomPort(struct libalias *la) {
u_short port;
port = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
return ntohs(port);
}
/* GetNewPort() allocates port numbers. Note that if a port number /* GetNewPort() allocates port numbers. Note that if a port number
is already in use, that does not mean that it cannot be used by is already in use, that does not mean that it cannot be used by
another link concurrently. This is because GetNewPort() looks for another link concurrently. This is because GetNewPort() looks for
unused triplets: (dest addr, dest port, alias port). */ unused triplets: (dest addr, dest port, alias port). */
static int static int
GetNewPort(struct libalias *la, struct alias_link *lnk, int alias_port_param) GetNewPort(struct libalias *la, struct alias_link *lnk, int alias_port_param)
{ {
int i; int i;
int max_trials; int max_trials;
u_short port_sys; u_short port;
u_short port_net;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* /*
* Description of alias_port_param for GetNewPort(). When * Description of alias_port_param for GetNewPort(). When
* this parameter is zero or positive, it precisely specifies * this parameter is zero or positive, it precisely specifies
* the port number. GetNewPort() will return this number * the port number. GetNewPort() will return this number
* without check that it is in use. * without check that it is in use.
*
* The aliasing port is automatically selected by one of
* two methods below:
*
* When this parameter is GET_ALIAS_PORT, it indicates to get * When this parameter is GET_ALIAS_PORT, it indicates to get
* a randomly selected port number. * a randomly selected port number.
*/ */
if (alias_port_param == GET_ALIAS_PORT) { if (alias_port_param >= 0 && alias_port_param < 0x10000) {
/*
* The aliasing port is automatically selected by one of
* two methods below:
*/
max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) {
/*
* When the PKT_ALIAS_SAME_PORTS option is chosen,
* the first try will be the actual source port. If
* this is already in use, the remainder of the
* trials will be random.
*/
port_net = lnk->src_port;
port_sys = ntohs(port_net);
} else if (la->aliasPortLower) {
/* First trial is a random port in the aliasing range. */
port_sys = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
port_net = htons(port_sys);
} else {
/* First trial and all subsequent are random. */
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
port_net = htons(port_sys);
}
} else if (alias_port_param >= 0 && alias_port_param < 0x10000) {
lnk->alias_port = (u_short) alias_port_param; lnk->alias_port = (u_short) alias_port_param;
return (0); return (0);
} else { }
if (alias_port_param != GET_ALIAS_PORT) {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/GetNewPort(): "); fprintf(stderr, "PacketAlias/GetNewPort(): ");
fprintf(stderr, "input parameter error\n"); fprintf(stderr, "input parameter error\n");
#endif #endif
return (-1); return (-1);
} }
max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
/*
* When the PKT_ALIAS_SAME_PORTS option is chosen,
* the first try will be the actual source port. If
* this is already in use, the remainder of the
* trials will be random.
*/
port = (la->packetAliasMode & PKT_ALIAS_SAME_PORTS)
? lnk->src_port
: _RandomPort(la);
/* Port number search */ /* Port number search */
for (i = 0; i < max_trials; i++) { for (i = 0; i < max_trials; i++, port = _RandomPort(la)) {
int go_ahead; struct group_in *grp;
struct alias_link *search_result; struct alias_link *search_result;
search_result = FindLinkIn(la, lnk->dst_addr, lnk->alias_addr, grp = StartPointIn(la, lnk->alias_addr, port, lnk->link_type, 0);
lnk->dst_port, port_net, if (grp == NULL)
lnk->link_type, 0); break;
LIST_FOREACH(search_result, &grp->full, all.in) {
if (lnk->dst_addr.s_addr == search_result->dst_addr.s_addr &&
lnk->dst_port == search_result->dst_port)
break; /* found match */
}
if (search_result == NULL) if (search_result == NULL)
go_ahead = 1; break;
else if (!(lnk->flags & LINK_PARTIALLY_SPECIFIED)
&& (search_result->flags & LINK_PARTIALLY_SPECIFIED))
go_ahead = 1;
else
go_ahead = 0;
if (go_ahead) {
#ifndef NO_USE_SOCKETS
if ((la->packetAliasMode & PKT_ALIAS_USE_SOCKETS)
&& (lnk->flags & LINK_PARTIALLY_SPECIFIED)
&& ((lnk->link_type == LINK_TCP) ||
(lnk->link_type == LINK_UDP))) {
if (GetSocket(la, port_net, &lnk->sockfd, lnk->link_type)) {
lnk->alias_port = port_net;
return (0);
} }
} else {
#endif
lnk->alias_port = port_net;
return (0);
#ifndef NO_USE_SOCKETS
}
#endif
}
if (la->aliasPortLower) {
port_sys = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
port_net = htons(port_sys);
} else {
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
port_net = htons(port_sys);
}
}
if (i >= max_trials) {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/GetNewPort(): "); fprintf(stderr, "PacketAlias/GetNewPort(): ");
fprintf(stderr, "could not find free port\n"); fprintf(stderr, "could not find free port\n");
#endif #endif
return (-1);
}
#ifndef NO_USE_SOCKETS
if ((la->packetAliasMode & PKT_ALIAS_USE_SOCKETS) &&
(lnk->flags & LINK_PARTIALLY_SPECIFIED) &&
((lnk->link_type == LINK_TCP) ||
(lnk->link_type == LINK_UDP))) {
if (!GetSocket(la, port, &lnk->sockfd, lnk->link_type)) {
return (-1); return (-1);
} }
}
#endif
lnk->alias_port = port;
return (0);
}
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
static u_short static u_short
GetSocket(struct libalias *la, u_short port_net, int *sockfd, int link_type) GetSocket(struct libalias *la, u_short port_net, int *sockfd, int link_type)
{ {
int err; int err;
int sock; int sock;
struct sockaddr_in sock_addr; struct sockaddr_in sock_addr;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 LinesFindNewPortGroup(struct libalias *la,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
u_short port_count, u_short port_count,
u_char proto, u_char proto,
u_char align) u_char align)
{ {
int i, j; int i, j;
int max_trials; int max_trials;
u_short port_sys; u_short port;
int link_type; int link_type;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* /*
* Get link_type from protocol * Get link_type from protocol
*/ */
switch (proto) { switch (proto) {
Show All 15 LinesFindNewPortGroup(struct libalias *la,
max_trials = GET_NEW_PORT_MAX_ATTEMPTS; max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) { if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) {
/* /*
* When the ALIAS_SAME_PORTS option is chosen, the first * When the ALIAS_SAME_PORTS option is chosen, the first
* try will be the actual source port. If this is already * try will be the actual source port. If this is already
* in use, the remainder of the trials will be random. * in use, the remainder of the trials will be random.
*/ */
port_sys = ntohs(src_port); port = src_port;
} else { } else {
/* First trial and all subsequent are random. */ port = _RandomPort(la);
if (align == FIND_EVEN_ALIAS_BASE)
port_sys = arc4random() & ALIAS_PORT_MASK_EVEN;
else
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
} }
/* Port number search */ /* Port number search */
for (i = 0; i < max_trials; i++) { for (i = 0; i < max_trials; i++, port = _RandomPort(la)) {
struct alias_link *search_result; struct alias_link *search_result;
for (j = 0; j < port_count; j++) if (align)
port &= htons(0xfffe);
for (j = 0; j < port_count; j++) {
u_short port_j = ntohs(port) + j;
if ((search_result = FindLinkIn(la, dst_addr, if ((search_result = FindLinkIn(la, dst_addr,
alias_addr, dst_port, htons(port_sys + j), alias_addr, dst_port, htons(port_j),
link_type, 0)) != NULL) link_type, 0)) != NULL)
break; break;
}
/* Found a good range, return base */ /* Found a good range, return base */
if (j == port_count) if (j == port_count)
return (htons(port_sys)); return (port);
/* Find a new base to try */
if (align == FIND_EVEN_ALIAS_BASE)
port_sys = arc4random() & ALIAS_PORT_MASK_EVEN;
else
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
} }
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/FindNewPortGroup(): "); fprintf(stderr, "PacketAlias/FindNewPortGroup(): ");
fprintf(stderr, "could not find free port(s)\n"); fprintf(stderr, "could not find free port(s)\n");
#endif #endif
return (0); return (0);
} }
static void static void
CleanupAliasData(struct libalias *la) CleanupAliasData(struct libalias *la)
{ {
struct alias_link *lnk, *lnk_tmp; struct alias_link *lnk, *lnk_tmp;
u_int i;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* permanent entries may stay */ /* permanent entries may stay */
TAILQ_FOREACH_SAFE(lnk, &la->checkExpire, list_expire, lnk_tmp) TAILQ_FOREACH_SAFE(lnk, &la->checkExpire, expire.list, lnk_tmp)
DeleteLink(&lnk); DeleteLink(&lnk);
for (i = 0; i < LINK_TABLE_IN_SIZE; i++) {
struct group_in *grp, *grp_tmp;
LIST_FOREACH_SAFE(grp, &la->groupTableIn[i], group_in, grp_tmp)
if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {
LIST_REMOVE(grp, group_in);
free(grp);
} }
}
}
static void static void
CleanupLink(struct libalias *la, struct alias_link **lnk) CleanupLink(struct libalias *la, struct alias_link **lnk)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
if (lnk == NULL || *lnk == NULL) if (lnk == NULL || *lnk == NULL)
return; return;
if (LibAliasTime - (*lnk)->timestamp > (*lnk)->expire_time) { if (LibAliasTime - (*lnk)->timestamp > (*lnk)->expire.timeout) {
DeleteLink(lnk); DeleteLink(lnk);
if ((*lnk) == NULL) if ((*lnk) == NULL)
return; return;
} }
/* move to end, swap may fail on a single entry list */ /* move to end, swap may fail on a single entry list */
TAILQ_REMOVE(&la->checkExpire, (*lnk), list_expire); TAILQ_REMOVE(&la->checkExpire, (*lnk), expire.list);
TAILQ_INSERT_TAIL(&la->checkExpire, (*lnk), list_expire); TAILQ_INSERT_TAIL(&la->checkExpire, (*lnk), expire.list);
} }
static struct alias_link *
UseLink(struct libalias *la, struct alias_link *lnk)
{
CleanupLink(la, &lnk);
if (lnk != NULL)
lnk->timestamp = LibAliasTime;
return (lnk);
}
static void static void
DeleteLink(struct alias_link **plnk) DeleteLink(struct alias_link **plnk)
{ {
struct alias_link *lnk = *plnk; struct alias_link *lnk = *plnk;
struct libalias *la = lnk->la; struct libalias *la = lnk->la;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* Don't do anything if the link is marked permanent */ /* Don't do anything if the link is marked permanent */
if (la->deleteAllLinks == 0 && lnk->flags & LINK_PERMANENT) if (la->deleteAllLinks == 0 && lnk->flags & LINK_PERMANENT)
return; return;
#ifndef NO_FW_PUNCH #ifndef NO_FW_PUNCH
/* Delete associated firewall hole, if any */ /* Delete associated firewall hole, if any */
ClearFWHole(lnk); ClearFWHole(lnk);
#endif #endif
switch (lnk->link_type) {
case LINK_PPTP:
LIST_REMOVE(lnk, pptp.list);
break;
default:
/* Free memory allocated for LSNAT server pool */ /* Free memory allocated for LSNAT server pool */
if (lnk->server != NULL) { if (lnk->server != NULL) {
struct server *head, *curr, *next; struct server *head, *curr, *next;
head = curr = lnk->server; head = curr = lnk->server;
do { do {
next = curr->next; next = curr->next;
free(curr); free(curr);
} while ((curr = next) != head); } while ((curr = next) != head);
} } else {
/* Adjust output table pointers */ /* Adjust output table pointers */
LIST_REMOVE(lnk, list_out); LIST_REMOVE(lnk, all.out);
}
/* Adjust input table pointers */ /* Adjust input table pointers */
LIST_REMOVE(lnk, list_in); LIST_REMOVE(lnk, all.in);
break;
}
/* remove from housekeeping */ /* remove from housekeeping */
TAILQ_REMOVE(&la->checkExpire, lnk, list_expire); TAILQ_REMOVE(&la->checkExpire, lnk, expire.list);
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
/* Close socket, if one has been allocated */ /* Close socket, if one has been allocated */
if (lnk->sockfd != -1) { if (lnk->sockfd != -1) {
la->sockCount--; la->sockCount--;
close(lnk->sockfd); close(lnk->sockfd);
} }
#endif #endif
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
AddLink(struct libalias *la, struct in_addr src_addr, struct in_addr dst_addr, AddLink(struct libalias *la, struct in_addr src_addr, struct in_addr dst_addr,
struct in_addr alias_addr, u_short src_port, u_short dst_port, struct in_addr alias_addr, u_short src_port, u_short dst_port,
int alias_port_param, int link_type) int alias_port_param, int link_type)
{ {
u_int start_point; u_int start_point;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = malloc(sizeof(struct alias_link)); lnk = malloc(sizeof(struct alias_link));
if (lnk != NULL) { if (lnk == NULL) {
#ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink(): ");
fprintf(stderr, "malloc() call failed.\n");
#endif
return (NULL);
}
/* Basic initialization */ /* Basic initialization */
lnk->la = la; lnk->la = la;
lnk->src_addr = src_addr; lnk->src_addr = src_addr;
lnk->dst_addr = dst_addr; lnk->dst_addr = dst_addr;
lnk->alias_addr = alias_addr; lnk->alias_addr = alias_addr;
lnk->proxy_addr.s_addr = INADDR_ANY; lnk->proxy_addr.s_addr = INADDR_ANY;
lnk->src_port = src_port; lnk->src_port = src_port;
lnk->dst_port = dst_port; lnk->dst_port = dst_port;
lnk->proxy_port = 0; lnk->proxy_port = 0;
lnk->server = NULL; lnk->server = NULL;
lnk->link_type = link_type; lnk->link_type = link_type;
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
lnk->sockfd = -1; lnk->sockfd = -1;
#endif #endif
lnk->flags = 0; lnk->flags = 0;
lnk->pflags = 0; lnk->pflags = 0;
lnk->timestamp = LibAliasTime; lnk->timestamp = LibAliasTime;
/* Expiration time */ /* Expiration time */
switch (link_type) { switch (link_type) {
case LINK_ICMP: case LINK_ICMP:
lnk->expire_time = ICMP_EXPIRE_TIME; lnk->expire.timeout = ICMP_EXPIRE_TIME;
break; break;
case LINK_UDP: case LINK_UDP:
lnk->expire_time = UDP_EXPIRE_TIME; lnk->expire.timeout = UDP_EXPIRE_TIME;
break; break;
case LINK_TCP: case LINK_TCP:
lnk->expire_time = TCP_EXPIRE_INITIAL; lnk->expire.timeout = TCP_EXPIRE_INITIAL;
break; break;
case LINK_PPTP:
lnk->flags |= LINK_PERMANENT; /* no timeout. */
break;
case LINK_FRAGMENT_ID: case LINK_FRAGMENT_ID:
lnk->expire_time = FRAGMENT_ID_EXPIRE_TIME; lnk->expire.timeout = FRAGMENT_ID_EXPIRE_TIME;
break; break;
case LINK_FRAGMENT_PTR: case LINK_FRAGMENT_PTR:
lnk->expire_time = FRAGMENT_PTR_EXPIRE_TIME; lnk->expire.timeout = FRAGMENT_PTR_EXPIRE_TIME;
break; break;
case LINK_ADDR: case LINK_ADDR:
break; break;
default: default:
lnk->expire_time = PROTO_EXPIRE_TIME; lnk->expire.timeout = PROTO_EXPIRE_TIME;
break; break;
} }
/* Determine alias flags */ /* Determine alias flags */
if (dst_addr.s_addr == INADDR_ANY) if (dst_addr.s_addr == INADDR_ANY)
lnk->flags |= LINK_UNKNOWN_DEST_ADDR; lnk->flags |= LINK_UNKNOWN_DEST_ADDR;
if (dst_port == 0) if (dst_port == 0)
lnk->flags |= LINK_UNKNOWN_DEST_PORT; lnk->flags |= LINK_UNKNOWN_DEST_PORT;
/* Determine alias port */ /* Determine alias port */
if (GetNewPort(la, lnk, alias_port_param) != 0) { if (GetNewPort(la, lnk, alias_port_param) != 0) {
free(lnk); free(lnk);
return (NULL); return (NULL);
} }
/* Link-type dependent initialization */ /* Link-type dependent initialization */
switch (link_type) { switch (link_type) {
struct tcp_dat *aux_tcp;
case LINK_ICMP: case LINK_ICMP:
la->icmpLinkCount++; la->icmpLinkCount++;
break; break;
case LINK_UDP: case LINK_UDP:
la->udpLinkCount++; la->udpLinkCount++;
break; break;
case LINK_TCP: case LINK_TCP: {
struct tcp_dat *aux_tcp;
int i;
aux_tcp = malloc(sizeof(struct tcp_dat)); aux_tcp = malloc(sizeof(struct tcp_dat));
if (aux_tcp != NULL) { if (aux_tcp != NULL) {
int i; #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink: ");
fprintf(stderr, " cannot allocate auxiliary TCP data\n");
#endif
free(lnk);
return (NULL);
}
la->tcpLinkCount++; la->tcpLinkCount++;
aux_tcp->state.in = ALIAS_TCP_STATE_NOT_CONNECTED; aux_tcp->state.in = ALIAS_TCP_STATE_NOT_CONNECTED;
aux_tcp->state.out = ALIAS_TCP_STATE_NOT_CONNECTED; aux_tcp->state.out = ALIAS_TCP_STATE_NOT_CONNECTED;
aux_tcp->state.index = 0; aux_tcp->state.index = 0;
aux_tcp->state.ack_modified = 0; aux_tcp->state.ack_modified = 0;
for (i = 0; i < N_LINK_TCP_DATA; i++) for (i = 0; i < N_LINK_TCP_DATA; i++)
aux_tcp->ack[i].active = 0; aux_tcp->ack[i].active = 0;
aux_tcp->fwhole = -1; aux_tcp->fwhole = -1;
lnk->data.tcp = aux_tcp; lnk->data.tcp = aux_tcp;
} else {
#ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink: ");
fprintf(stderr, " cannot allocate auxiliary TCP data\n");
#endif
free(lnk);
return (NULL);
} }
break; break;
case LINK_PPTP: case LINK_PPTP:
la->pptpLinkCount++; la->pptpLinkCount++;
break; break;
case LINK_FRAGMENT_ID: case LINK_FRAGMENT_ID:
la->fragmentIdLinkCount++; la->fragmentIdLinkCount++;
break; break;
case LINK_FRAGMENT_PTR: case LINK_FRAGMENT_PTR:
la->fragmentPtrLinkCount++; la->fragmentPtrLinkCount++;
break; break;
case LINK_ADDR: case LINK_ADDR:
break; break;
default: default:
la->protoLinkCount++; la->protoLinkCount++;
break; break;
} }
switch (link_type) {
case LINK_PPTP:
LIST_INSERT_HEAD(&la->pptpTable, lnk, pptp.list);
break;
default: {
struct group_in *grp;
grp = StartPointIn(la, alias_addr, lnk->alias_port, link_type, 1);
if (grp == NULL) {
free(lnk);
return (NULL);
}
/* Set up pointers for output lookup table */ /* Set up pointers for output lookup table */
start_point = StartPointOut(src_addr, dst_addr, start_point = StartPointOut(src_addr, dst_addr,
src_port, dst_port, link_type); src_port, dst_port, link_type);
LIST_INSERT_HEAD(&la->linkTableOut[start_point], lnk, list_out); LIST_INSERT_HEAD(&la->linkTableOut[start_point], lnk, all.out);
/* Set up pointers for input lookup table */ /* Set up pointers for input lookup table */
start_point = StartPointIn(alias_addr, lnk->alias_port, link_type); if (lnk->flags & LINK_PARTIALLY_SPECIFIED)
LIST_INSERT_HEAD(&la->linkTableIn[start_point], lnk, list_in); LIST_INSERT_HEAD(&grp->partial, lnk, all.in);
else
LIST_INSERT_HEAD(&grp->full, lnk, all.in);
}
break;
}
/* Include the element into the housekeeping list */ /* Include the element into the housekeeping list */
TAILQ_INSERT_TAIL(&la->checkExpire, lnk, list_expire); TAILQ_INSERT_TAIL(&la->checkExpire, lnk, expire.list);
} else {
#ifdef LIBALIAS_DEBUG if (la->packetAliasMode & PKT_ALIAS_LOG)
fprintf(stderr, "PacketAlias/AddLink(): ");
fprintf(stderr, "malloc() call failed.\n");
#endif
}
if (la->packetAliasMode & PKT_ALIAS_LOG) {
ShowAliasStats(la); ShowAliasStats(la);
}
return (lnk); return (lnk);
} }
/* /*
* If alias_port_param is less than zero, alias port will be automatically * If alias_port_param is less than zero, alias port will be automatically
* chosen. If greater than zero, equal to alias port * chosen. If greater than zero, equal to alias port
*/ */
static struct alias_link * static struct alias_link *
Show All 19 Lines if (new_lnk != NULL &&
old_lnk->data.tcp->fwhole > 0) { old_lnk->data.tcp->fwhole > 0) {
PunchFWHole(new_lnk); PunchFWHole(new_lnk);
} }
#endif #endif
DeleteLink(&old_lnk); DeleteLink(&old_lnk);
return (new_lnk); return (new_lnk);
} }
#define OUTGUARD \
if (lnk->src_port != src_port || \
lnk->src_addr.s_addr != src_addr.s_addr || \
lnk->dst_addr.s_addr != dst_addr.s_addr || \
lnk->dst_port != dst_port || \
lnk->link_type != link_type) \
continue;
static struct alias_link * static struct alias_link *
_SearchLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr,
u_short src_port,
u_short dst_port,
int link_type) {
u_int i;
struct alias_link *lnk;
i = StartPointOut(src_addr, dst_addr, src_port, dst_port, link_type);
LIST_FOREACH(lnk, &la->linkTableOut[i], all.out) {
OUTGUARD;
return (UseLink(la, lnk));
}
return (NULL);
}
#undef OUTGUARD
static struct alias_link *
_FindLinkOut(struct libalias *la, struct in_addr src_addr, _FindLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
int link_type, int link_type,
int replace_partial_links) int replace_partial_links)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, src_port, dst_port, link_type); lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, dst_port, link_type);
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) { if (lnk != NULL || !replace_partial_links)
if (lnk->dst_addr.s_addr == dst_addr.s_addr && return (lnk);
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->src_port == src_port &&
lnk->dst_port == dst_port &&
lnk->link_type == link_type &&
lnk->server == NULL)
break;
}
CleanupLink(la, &lnk);
if (lnk != NULL)
lnk->timestamp = LibAliasTime;
/* Search for partially specified links. */ /* Search for partially specified links. */
if (lnk == NULL && replace_partial_links) {
if (dst_port != 0 && dst_addr.s_addr != INADDR_ANY) { if (dst_port != 0 && dst_addr.s_addr != INADDR_ANY) {
lnk = _FindLinkOut(la, src_addr, dst_addr, src_port, 0, lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, 0,
link_type, 0); link_type);
if (lnk == NULL) if (lnk == NULL)
lnk = _FindLinkOut(la, src_addr, NO_ADDR, src_port, lnk = _SearchLinkOut(la, src_addr, ANY_ADDR, src_port,
dst_port, link_type, 0); dst_port, link_type);
} }
if (lnk == NULL && if (lnk == NULL &&
(dst_port != 0 || dst_addr.s_addr != INADDR_ANY)) { (dst_port != 0 || dst_addr.s_addr != INADDR_ANY)) {
lnk = _FindLinkOut(la, src_addr, NO_ADDR, src_port, 0, lnk = _SearchLinkOut(la, src_addr, ANY_ADDR, src_port, 0,
link_type, 0); link_type);
} }
if (lnk != NULL) { if (lnk != NULL) {
lnk = ReLink(lnk, lnk = ReLink(lnk,
src_addr, dst_addr, lnk->alias_addr, src_addr, dst_addr, lnk->alias_addr,
src_port, dst_port, lnk->alias_port, src_port, dst_port, lnk->alias_port,
link_type); link_type);
} }
}
return (lnk); return (lnk);
} }
static struct alias_link * static struct alias_link *
FindLinkOut(struct libalias *la, struct in_addr src_addr, FindLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
Show All 10 Lines if (lnk == NULL) {
/* /*
* The following allows permanent links to be specified as * The following allows permanent links to be specified as
* using the default source address (i.e. device interface * using the default source address (i.e. device interface
* address) without knowing in advance what that address * address) without knowing in advance what that address
* is. * is.
*/ */
if (la->aliasAddress.s_addr != INADDR_ANY && if (la->aliasAddress.s_addr != INADDR_ANY &&
src_addr.s_addr == la->aliasAddress.s_addr) { src_addr.s_addr == la->aliasAddress.s_addr) {
lnk = _FindLinkOut(la, NO_ADDR, dst_addr, src_port, dst_port, lnk = _FindLinkOut(la, ANY_ADDR, dst_addr, src_port, dst_port,
link_type, replace_partial_links); link_type, replace_partial_links);
} }
} }
return (lnk); return (lnk);
} }
static struct alias_link * static struct alias_link *
_FindLinkIn(struct libalias *la, struct in_addr dst_addr, _FindLinkIn(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_short dst_port, u_short dst_port,
u_short alias_port, u_short alias_port,
int link_type, int link_type,
int replace_partial_links) int replace_partial_links)
{ {
int flags_in; int flags_in;
u_int start_point; struct group_in *grp;
struct alias_link *lnk; struct alias_link *lnk;
struct alias_link *lnk_fully_specified;
struct alias_link *lnk_unknown_all; struct alias_link *lnk_unknown_all;
struct alias_link *lnk_unknown_dst_addr; struct alias_link *lnk_unknown_dst_addr;
struct alias_link *lnk_unknown_dst_port; struct alias_link *lnk_unknown_dst_port;
struct in_addr src_addr;
u_short src_port;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* Initialize pointers */ /* Initialize pointers */
lnk_fully_specified = NULL;
lnk_unknown_all = NULL; lnk_unknown_all = NULL;
lnk_unknown_dst_addr = NULL; lnk_unknown_dst_addr = NULL;
lnk_unknown_dst_port = NULL; lnk_unknown_dst_port = NULL;
/* If either the dest addr or port is unknown, the search /* If either the dest addr or port is unknown, the search
* loop will have to know about this. */ * loop will have to know about this. */
flags_in = 0; flags_in = 0;
if (dst_addr.s_addr == INADDR_ANY) if (dst_addr.s_addr == INADDR_ANY)
flags_in |= LINK_UNKNOWN_DEST_ADDR; flags_in |= LINK_UNKNOWN_DEST_ADDR;
if (dst_port == 0) if (dst_port == 0)
flags_in |= LINK_UNKNOWN_DEST_PORT; flags_in |= LINK_UNKNOWN_DEST_PORT;
/* Search loop */ /* Search loop */
start_point = StartPointIn(alias_addr, alias_port, link_type); grp = StartPointIn(la, alias_addr, alias_port, link_type, 0);
LIST_FOREACH(lnk, &la->linkTableIn[start_point], list_in) { if (grp == NULL)
int flags; return (NULL);
flags = flags_in | lnk->flags; switch (flags_in) {
if (!(flags & LINK_PARTIALLY_SPECIFIED)) { case 0:
if (lnk->alias_addr.s_addr == alias_addr.s_addr LIST_FOREACH(lnk, &grp->full, all.in) {
&& lnk->alias_port == alias_port if (lnk->dst_addr.s_addr == dst_addr.s_addr &&
&& lnk->dst_addr.s_addr == dst_addr.s_addr lnk->dst_port == dst_port)
&& lnk->dst_port == dst_port return (UseLink(la, lnk));
&& lnk->link_type == link_type) { }
lnk_fully_specified = lnk;
break; break;
case LINK_UNKNOWN_DEST_PORT:
LIST_FOREACH(lnk, &grp->full, all.in) {
if(lnk->dst_addr.s_addr == dst_addr.s_addr) {
lnk_unknown_dst_port = lnk;
break;
} }
} else if ((flags & LINK_UNKNOWN_DEST_ADDR)
&& (flags & LINK_UNKNOWN_DEST_PORT)) {
if (lnk->alias_addr.s_addr == alias_addr.s_addr
&& lnk->alias_port == alias_port
&& lnk->link_type == link_type) {
if (lnk_unknown_all == NULL)
lnk_unknown_all = lnk;
} }
} else if (flags & LINK_UNKNOWN_DEST_ADDR) { break;
if (lnk->alias_addr.s_addr == alias_addr.s_addr case LINK_UNKNOWN_DEST_ADDR:
&& lnk->alias_port == alias_port LIST_FOREACH(lnk, &grp->full, all.in) {
&& lnk->link_type == link_type if(lnk->dst_port == dst_port) {
&& lnk->dst_port == dst_port) {
if (lnk_unknown_dst_addr == NULL)
lnk_unknown_dst_addr = lnk; lnk_unknown_dst_addr = lnk;
break;
} }
} else if (flags & LINK_UNKNOWN_DEST_PORT) { }
if (lnk->alias_addr.s_addr == alias_addr.s_addr break;
&& lnk->alias_port == alias_port case LINK_PARTIALLY_SPECIFIED:
&& lnk->link_type == link_type lnk_unknown_all = LIST_FIRST(&grp->full);
&& lnk->dst_addr.s_addr == dst_addr.s_addr) { break;
if (lnk_unknown_dst_port == NULL) }
if (lnk_unknown_dst_port == NULL) {
LIST_FOREACH(lnk, &grp->partial, all.in) {
int flags = (flags_in | lnk->flags) & LINK_PARTIALLY_SPECIFIED;
if (flags == LINK_PARTIALLY_SPECIFIED &&
lnk_unknown_all == NULL)
lnk_unknown_all = lnk;
if (flags == LINK_UNKNOWN_DEST_ADDR &&
lnk->dst_port == dst_port &&
lnk_unknown_dst_addr == NULL)
lnk_unknown_dst_addr = lnk;
if (flags == LINK_UNKNOWN_DEST_PORT &&
lnk->dst_addr.s_addr == dst_addr.s_addr) {
lnk_unknown_dst_port = lnk; lnk_unknown_dst_port = lnk;
break;
} }
} }
} }
CleanupLink(la, &lnk_fully_specified); lnk = (lnk_unknown_dst_port != NULL) ? lnk_unknown_dst_port
if (lnk_fully_specified != NULL) { : (lnk_unknown_dst_addr != NULL) ? lnk_unknown_dst_addr
lnk_fully_specified->timestamp = LibAliasTime; : lnk_unknown_all;
lnk = lnk_fully_specified;
} else if (lnk_unknown_dst_port != NULL)
lnk = lnk_unknown_dst_port;
else if (lnk_unknown_dst_addr != NULL)
lnk = lnk_unknown_dst_addr;
else if (lnk_unknown_all != NULL)
lnk = lnk_unknown_all;
else
return (NULL);
if (replace_partial_links && if (lnk == NULL || !replace_partial_links)
(lnk->flags & LINK_PARTIALLY_SPECIFIED || lnk->server != NULL)) { return (lnk);
struct in_addr src_addr;
u_short src_port;
if (lnk->server != NULL) { /* LSNAT link */ if (lnk->server != NULL) { /* LSNAT link */
src_addr = lnk->server->addr; src_addr = lnk->server->addr;
src_port = lnk->server->port; src_port = lnk->server->port;
lnk->server = lnk->server->next; lnk->server = lnk->server->next;
} else { } else {
src_addr = lnk->src_addr; src_addr = lnk->src_addr;
src_port = lnk->src_port; src_port = lnk->src_port;
} }
if (link_type == LINK_SCTP) { if (link_type == LINK_SCTP) {
lnk->src_addr = src_addr; lnk->src_addr = src_addr;
lnk->src_port = src_port; lnk->src_port = src_port;
return (lnk); } else {
}
lnk = ReLink(lnk, lnk = ReLink(lnk,
src_addr, dst_addr, alias_addr, src_addr, dst_addr, alias_addr,
src_port, dst_port, alias_port, src_port, dst_port, alias_port,
link_type); link_type);
} }
return (lnk); return (lnk);
} }
Show All 15 Lines if (lnk == NULL) {
/* /*
* The following allows permanent links to be specified as * The following allows permanent links to be specified as
* using the default aliasing address (i.e. device * using the default aliasing address (i.e. device
* interface address) without knowing in advance what that * interface address) without knowing in advance what that
* address is. * address is.
*/ */
if (la->aliasAddress.s_addr != INADDR_ANY && if (la->aliasAddress.s_addr != INADDR_ANY &&
alias_addr.s_addr == la->aliasAddress.s_addr) { alias_addr.s_addr == la->aliasAddress.s_addr) {
lnk = _FindLinkIn(la, dst_addr, NO_ADDR, dst_port, alias_port, lnk = _FindLinkIn(la, dst_addr, ANY_ADDR, dst_port, alias_port,
link_type, replace_partial_links); link_type, replace_partial_links);
} }
} }
return (lnk); return (lnk);
} }
/* External routines for finding/adding links /* External routines for finding/adding links
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 LinesFindFragmentIn1(struct libalias *la, struct in_addr dst_addr,
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, dst_addr, alias_addr, lnk = FindLinkIn(la, dst_addr, alias_addr,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID, 0); LINK_FRAGMENT_ID, 0);
if (lnk == NULL) { if (lnk == NULL) {
lnk = AddLink(la, NO_ADDR, dst_addr, alias_addr, lnk = AddLink(la, ANY_ADDR, dst_addr, alias_addr,
NO_SRC_PORT, NO_DEST_PORT, ip_id, NO_SRC_PORT, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID); LINK_FRAGMENT_ID);
} }
return (lnk); return (lnk);
} }
/* Doesn't add a link if one is not found. */ /* Doesn't add a link if one is not found. */
struct alias_link * struct alias_link *
FindFragmentIn2(struct libalias *la, struct in_addr dst_addr, FindFragmentIn2(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, u_short ip_id) struct in_addr alias_addr, u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return FindLinkIn(la, dst_addr, alias_addr, return FindLinkIn(la, dst_addr, alias_addr,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID, 0); LINK_FRAGMENT_ID, 0);
} }
struct alias_link * struct alias_link *
AddFragmentPtrLink(struct libalias *la, struct in_addr dst_addr, AddFragmentPtrLink(struct libalias *la, struct in_addr dst_addr,
u_short ip_id) u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return AddLink(la, NO_ADDR, dst_addr, NO_ADDR, return AddLink(la, ANY_ADDR, dst_addr, ANY_ADDR,
NO_SRC_PORT, NO_DEST_PORT, ip_id, NO_SRC_PORT, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_PTR); LINK_FRAGMENT_PTR);
} }
struct alias_link * struct alias_link *
FindFragmentPtr(struct libalias *la, struct in_addr dst_addr, FindFragmentPtr(struct libalias *la, struct in_addr dst_addr,
u_short ip_id) u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return FindLinkIn(la, dst_addr, NO_ADDR, return FindLinkIn(la, dst_addr, ANY_ADDR,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_PTR, 0); LINK_FRAGMENT_PTR, 0);
} }
struct alias_link * struct alias_link *
FindProtoIn(struct libalias *la, struct in_addr dst_addr, FindProtoIn(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_char proto) u_char proto)
▲ Show 20 Lines • Show All 131 Lines • ▼ Show 20 LinesAddPptp(struct libalias *la, struct in_addr src_addr,
return (lnk); return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpOutByCallId(struct libalias *la, struct in_addr src_addr, FindPptpOutByCallId(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_int16_t src_call_id) u_int16_t src_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, 0, 0, LINK_PPTP); LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) if (lnk->src_addr.s_addr == src_addr.s_addr &&
if (lnk->link_type == LINK_PPTP &&
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->src_port == src_call_id) lnk->src_port == src_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpOutByPeerCallId(struct libalias *la, struct in_addr src_addr, FindPptpOutByPeerCallId(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_int16_t dst_call_id) u_int16_t dst_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, 0, 0, LINK_PPTP); LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) if (lnk->src_addr.s_addr == src_addr.s_addr &&
if (lnk->link_type == LINK_PPTP &&
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->dst_port == dst_call_id) lnk->dst_port == dst_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpInByCallId(struct libalias *la, struct in_addr dst_addr, FindPptpInByCallId(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_int16_t dst_call_id) u_int16_t dst_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointIn(alias_addr, 0, LINK_PPTP);
LIST_FOREACH(lnk, &la->linkTableIn[i], list_in) LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
if (lnk->link_type == LINK_PPTP && if (lnk->dst_port == dst_call_id &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->alias_addr.s_addr == alias_addr.s_addr && lnk->alias_addr.s_addr == alias_addr.s_addr)
lnk->dst_port == dst_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpInByPeerCallId(struct libalias *la, struct in_addr dst_addr, FindPptpInByPeerCallId(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_int16_t alias_call_id) u_int16_t alias_call_id)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, dst_addr, alias_addr, LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
0 /* any */ , alias_call_id, if (lnk->alias_port == alias_call_id &&
LINK_PPTP, 0); lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->alias_addr.s_addr == alias_addr.s_addr)
break;
return (lnk); return (lnk);
} }
struct alias_link * struct alias_link *
FindRtspOut(struct libalias *la, struct in_addr src_addr, FindRtspOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
Show All 30 Lines
} }
struct in_addr struct in_addr
FindOriginalAddress(struct libalias *la, struct in_addr alias_addr) FindOriginalAddress(struct libalias *la, struct in_addr alias_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, NO_ADDR, alias_addr, lnk = FindLinkIn(la, ANY_ADDR, alias_addr,
0, 0, LINK_ADDR, 0); 0, 0, LINK_ADDR, 0);
if (lnk == NULL) { if (lnk == NULL) {
la->newDefaultLink = 1; la->newDefaultLink = 1;
if (la->targetAddress.s_addr == INADDR_ANY) if (la->targetAddress.s_addr == INADDR_ANY)
return (alias_addr); return (alias_addr);
else if (la->targetAddress.s_addr == INADDR_NONE) else if (la->targetAddress.s_addr == INADDR_NONE)
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : alias_addr; la->aliasAddress : alias_addr;
Show All 15 Lines
} }
struct in_addr struct in_addr
FindAliasAddress(struct libalias *la, struct in_addr original_addr) FindAliasAddress(struct libalias *la, struct in_addr original_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkOut(la, original_addr, NO_ADDR, lnk = FindLinkOut(la, original_addr, ANY_ADDR,
0, 0, LINK_ADDR, 0); 0, 0, LINK_ADDR, 0);
if (lnk == NULL) { if (lnk == NULL) {
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : original_addr; la->aliasAddress : original_addr;
} else { } else {
if (lnk->alias_addr.s_addr == INADDR_ANY) if (lnk->alias_addr.s_addr == INADDR_ANY)
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : original_addr; la->aliasAddress : original_addr;
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
void void
SetStateIn(struct alias_link *lnk, int state) SetStateIn(struct alias_link *lnk, int state)
{ {
/* TCP input state */ /* TCP input state */
switch (state) { switch (state) {
case ALIAS_TCP_STATE_DISCONNECTED: case ALIAS_TCP_STATE_DISCONNECTED:
if (lnk->data.tcp->state.out != ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.out != ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_DEAD; lnk->expire.timeout = TCP_EXPIRE_DEAD;
else else
lnk->expire_time = TCP_EXPIRE_SINGLEDEAD; lnk->expire.timeout = TCP_EXPIRE_SINGLEDEAD;
break; break;
case ALIAS_TCP_STATE_CONNECTED: case ALIAS_TCP_STATE_CONNECTED:
if (lnk->data.tcp->state.out == ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.out == ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_CONNECTED; lnk->expire.timeout = TCP_EXPIRE_CONNECTED;
break; break;
default: default:
#ifdef _KERNEL #ifdef _KERNEL
panic("libalias:SetStateIn() unknown state"); panic("libalias:SetStateIn() unknown state");
#else #else
abort(); abort();
#endif #endif
} }
lnk->data.tcp->state.in = state; lnk->data.tcp->state.in = state;
} }
void void
SetStateOut(struct alias_link *lnk, int state) SetStateOut(struct alias_link *lnk, int state)
{ {
/* TCP output state */ /* TCP output state */
switch (state) { switch (state) {
case ALIAS_TCP_STATE_DISCONNECTED: case ALIAS_TCP_STATE_DISCONNECTED:
if (lnk->data.tcp->state.in != ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.in != ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_DEAD; lnk->expire.timeout = TCP_EXPIRE_DEAD;
else else
lnk->expire_time = TCP_EXPIRE_SINGLEDEAD; lnk->expire.timeout = TCP_EXPIRE_SINGLEDEAD;
break; break;
case ALIAS_TCP_STATE_CONNECTED: case ALIAS_TCP_STATE_CONNECTED:
if (lnk->data.tcp->state.in == ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.in == ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_CONNECTED; lnk->expire.timeout = TCP_EXPIRE_CONNECTED;
break; break;
default: default:
#ifdef _KERNEL #ifdef _KERNEL
panic("libalias:SetStateOut() unknown state"); panic("libalias:SetStateOut() unknown state");
#else #else
abort(); abort();
#endif #endif
} }
▲ Show 20 Lines • Show All 232 Lines • ▼ Show 20 Lines
SetExpire(struct alias_link *lnk, int expire) SetExpire(struct alias_link *lnk, int expire)
{ {
if (expire == 0) { if (expire == 0) {
lnk->flags &= ~LINK_PERMANENT; lnk->flags &= ~LINK_PERMANENT;
DeleteLink(&lnk); DeleteLink(&lnk);
} else if (expire == -1) { } else if (expire == -1) {
lnk->flags |= LINK_PERMANENT; lnk->flags |= LINK_PERMANENT;
} else if (expire > 0) { } else if (expire > 0) {
lnk->expire_time = expire; lnk->expire.timeout = expire;
} else { } else {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/SetExpire(): "); fprintf(stderr, "PacketAlias/SetExpire(): ");
fprintf(stderr, "error in expire parameter\n"); fprintf(stderr, "error in expire parameter\n");
#endif #endif
} }
} }
▲ Show 20 Lines • Show All 187 Lines • ▼ Show 20 Lines
LibAliasAddServer(struct libalias *la, struct alias_link *lnk, struct in_addr addr, u_short port) LibAliasAddServer(struct libalias *la, struct alias_link *lnk, struct in_addr addr, u_short port)
{ {
struct server *server; struct server *server;
int res; int res;
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
(void)la; (void)la;
switch (lnk->link_type) {
case LINK_PPTP:
server = NULL;
break;
default:
server = malloc(sizeof(struct server)); server = malloc(sizeof(struct server));
break;
}
if (server != NULL) { if (server != NULL) {
struct server *head; struct server *head;
server->addr = addr; server->addr = addr;
server->port = port; server->port = port;
head = lnk->server; head = lnk->server;
if (head == NULL) if (head == NULL) {
server->next = server; server->next = server;
else { /* not usable for outgoing connections */
LIST_REMOVE(lnk, all.out);
} else {
struct server *s; struct server *s;
for (s = head; s->next != head; s = s->next) for (s = head; s->next != head; s = s->next)
; ;
s->next = server; s->next = server;
server->next = head; server->next = head;
} }
lnk->server = server; lnk->server = server;
Show All 37 Lines
/* Static address translation */ /* Static address translation */
struct alias_link * struct alias_link *
LibAliasRedirectAddr(struct libalias *la, struct in_addr src_addr, LibAliasRedirectAddr(struct libalias *la, struct in_addr src_addr,
struct in_addr alias_addr) struct in_addr alias_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
lnk = AddLink(la, src_addr, NO_ADDR, alias_addr, lnk = AddLink(la, src_addr, ANY_ADDR, alias_addr,
0, 0, 0, 0, 0, 0,
LINK_ADDR); LINK_ADDR);
if (lnk != NULL) { if (lnk != NULL) {
lnk->flags |= LINK_PERMANENT; lnk->flags |= LINK_PERMANENT;
} }
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
else { else {
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines#ifdef _KERNEL
LibAliasTime = time_uptime; LibAliasTime = time_uptime;
#else #else
LibAliasTime = time(NULL); LibAliasTime = time(NULL);
#endif #endif
for (i = 0; i < LINK_TABLE_OUT_SIZE; i++) for (i = 0; i < LINK_TABLE_OUT_SIZE; i++)
LIST_INIT(&la->linkTableOut[i]); LIST_INIT(&la->linkTableOut[i]);
for (i = 0; i < LINK_TABLE_IN_SIZE; i++) for (i = 0; i < LINK_TABLE_IN_SIZE; i++)
LIST_INIT(&la->linkTableIn[i]); LIST_INIT(&la->groupTableIn[i]);
LIST_INIT(&la->pptpTable);
TAILQ_INIT(&la->checkExpire); TAILQ_INIT(&la->checkExpire);
#ifdef _KERNEL #ifdef _KERNEL
AliasSctpInit(la); AliasSctpInit(la);
#endif #endif
LIBALIAS_LOCK_INIT(la); LIBALIAS_LOCK_INIT(la);
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
} else { } else {
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
la->deleteAllLinks = 1; la->deleteAllLinks = 1;
CleanupAliasData(la); CleanupAliasData(la);
la->deleteAllLinks = 0; la->deleteAllLinks = 0;
#ifdef _KERNEL #ifdef _KERNEL
AliasSctpTerm(la); AliasSctpTerm(la);
AliasSctpInit(la); AliasSctpInit(la);
#endif #endif
} }
la->aliasAddress.s_addr = INADDR_ANY; la->aliasAddress.s_addr = INADDR_ANY;
la->targetAddress.s_addr = INADDR_ANY; la->targetAddress.s_addr = INADDR_ANY;
la->aliasPortLower = 0x8000;
la->aliasPortLength = 0x8000;
la->icmpLinkCount = 0; la->icmpLinkCount = 0;
la->udpLinkCount = 0; la->udpLinkCount = 0;
la->tcpLinkCount = 0; la->tcpLinkCount = 0;
la->sctpLinkCount = 0; la->sctpLinkCount = 0;
la->pptpLinkCount = 0; la->pptpLinkCount = 0;
la->protoLinkCount = 0; la->protoLinkCount = 0;
la->fragmentIdLinkCount = 0; la->fragmentIdLinkCount = 0;
▲ Show 20 Lines • Show All 380 Lines • Show Last 20 Lines
View Options

multimedia/libxine/files/patch-configure

Show First 20 Lines • Show All 214 Lines • ▼ Show 20 Lines
/* Dummy port number codes used for FindLinkIn/Out() and AddLink(). /* Dummy port number codes used for FindLinkIn/Out() and AddLink().
These constants can be anything except zero, which indicates an These constants can be anything except zero, which indicates an
unknown port number. */ unknown port number. */
#define NO_DEST_PORT 1 #define NO_DEST_PORT 1
#define NO_SRC_PORT 1 #define NO_SRC_PORT 1
/* Dummy address used for FindLinkIn/Out() and AddLink(). /* Matches any/unknown address in FindLinkIn/Out() and AddLink(). */
The value of this variable is never used. */ static struct in_addr const ANY_ADDR = { INADDR_ANY };
static struct in_addr const NO_ADDR;
/* Data Structures /* Data Structures
The fundamental data structure used in this program is The fundamental data structure used in this program is
"struct alias_link". Whenever a TCP connection is made, "struct alias_link". Whenever a TCP connection is made,
a UDP datagram is sent out, or an ICMP echo request is made, a UDP datagram is sent out, or an ICMP echo request is made,
a link record is made (if it has not already been created). a link record is made (if it has not already been created).
The link record is identified by the source address/port The link record is identified by the source address/port
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
/* flag bits */ /* flag bits */
#define LINK_UNKNOWN_DEST_PORT 0x01 #define LINK_UNKNOWN_DEST_PORT 0x01
#define LINK_UNKNOWN_DEST_ADDR 0x02 #define LINK_UNKNOWN_DEST_ADDR 0x02
#define LINK_PERMANENT 0x04 #define LINK_PERMANENT 0x04
#define LINK_PARTIALLY_SPECIFIED 0x03 /* logical-or of first two bits */ #define LINK_PARTIALLY_SPECIFIED 0x03 /* logical-or of first two bits */
#define LINK_UNFIREWALLED 0x08 #define LINK_UNFIREWALLED 0x08
int timestamp; /* Time link was last accessed */ int timestamp; /* Time link was last accessed */
int expire_time; /* Expire time for link */
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
int sockfd; /* socket descriptor */ int sockfd; /* socket descriptor */
#endif #endif
/* Linked list of pointers for input and output lookup tables */ /* Linked list of pointers for input and output lookup tables */
LIST_ENTRY (alias_link) list_out; union {
LIST_ENTRY (alias_link) list_in; struct {
TAILQ_ENTRY (alias_link) list_expire; LIST_ENTRY(alias_link) in;
LIST_ENTRY(alias_link) out;
} all;
struct {
LIST_ENTRY(alias_link) list;
} pptp;
};
struct {
TAILQ_ENTRY(alias_link) list;
int timeout; /* Expire time for link */
} expire;
/* Auxiliary data */ /* Auxiliary data */
union { union {
char *frag_ptr; char *frag_ptr;
struct in_addr frag_addr; struct in_addr frag_addr;
struct tcp_dat *tcp; struct tcp_dat *tcp;
} data; } data;
}; };
Show All 36 Lines StartPointOut() -- link table initial search point for
outgoing packets outgoing packets
Miscellaneous: Miscellaneous:
SeqDiff() -- difference between two TCP sequences SeqDiff() -- difference between two TCP sequences
ShowAliasStats() -- send alias statistics to a monitor file ShowAliasStats() -- send alias statistics to a monitor file
*/ */
/* Local prototypes */ /* Local prototypes */
static u_int StartPointIn(struct in_addr, u_short, int); static struct group_in *
StartPointIn(struct libalias *, struct in_addr, u_short, int, int);
static u_int static u_int
StartPointOut(struct in_addr, struct in_addr, StartPointOut(struct in_addr, struct in_addr, u_short, u_short, int);
u_short, u_short, int);
static int SeqDiff(u_long, u_long); static int SeqDiff(u_long, u_long);
#ifndef NO_FW_PUNCH #ifndef NO_FW_PUNCH
/* Firewall control */ /* Firewall control */
static void InitPunchFW(struct libalias *); static void InitPunchFW(struct libalias *);
static void UninitPunchFW(struct libalias *); static void UninitPunchFW(struct libalias *);
static void ClearFWHole(struct alias_link *); static void ClearFWHole(struct alias_link *);
#endif #endif
/* Log file control */ /* Log file control */
static void ShowAliasStats(struct libalias *); static void ShowAliasStats(struct libalias *);
static int InitPacketAliasLog(struct libalias *); static int InitPacketAliasLog(struct libalias *);
static void UninitPacketAliasLog(struct libalias *); static void UninitPacketAliasLog(struct libalias *);
void SctpShowAliasStats(struct libalias *la); void SctpShowAliasStats(struct libalias *la);
static u_int #define INGUARD \
StartPointIn(struct in_addr alias_addr, if (grp->alias_port != alias_port || \
u_short alias_port, grp->link_type != link_type || \
int link_type) grp->alias_addr.s_addr != alias_addr.s_addr) \
continue;
static struct group_in *
StartPointIn(struct libalias *la,
struct in_addr alias_addr, u_short alias_port, int link_type,
int create)
{ {
u_int n; u_int n;
struct group_in *grp, *tmp;
n = alias_addr.s_addr; n = alias_addr.s_addr;
if (link_type != LINK_PPTP)
n += alias_port; n += alias_port;
n += link_type; n += link_type;
return (n % LINK_TABLE_IN_SIZE); n %= LINK_TABLE_IN_SIZE;
LIST_FOREACH_SAFE(grp, &la->groupTableIn[n], group_in, tmp) {
/* Auto cleanup */
if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {
LIST_REMOVE(grp, group_in);
free(grp);
} else {
INGUARD;
return (grp);
} }
}
if (!create || (grp = malloc(sizeof(*grp))) == NULL)
return (grp);
grp->alias_addr = alias_addr;
grp->alias_port = alias_port;
grp->link_type = link_type;
LIST_INIT(&grp->full);
LIST_INIT(&grp->partial);
LIST_INSERT_HEAD(&la->groupTableIn[n], grp, group_in);
return (grp);
}
#undef INGUARD
static u_int static u_int
StartPointOut(struct in_addr src_addr, struct in_addr dst_addr, StartPointOut(struct in_addr src_addr, struct in_addr dst_addr,
u_short src_port, u_short dst_port, int link_type) u_short src_port, u_short dst_port, int link_type)
{ {
u_int n; u_int n;
n = src_addr.s_addr; n = src_addr.s_addr;
n += dst_addr.s_addr; n += dst_addr.s_addr;
if (link_type != LINK_PPTP) {
n += src_port; n += src_port;
n += dst_port; n += dst_port;
}
n += link_type; n += link_type;
return (n % LINK_TABLE_OUT_SIZE); return (n % LINK_TABLE_OUT_SIZE);
} }
static int static int
SeqDiff(u_long x, u_long y) SeqDiff(u_long x, u_long y)
{ {
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
/* Local prototypes */ /* Local prototypes */
static int GetNewPort(struct libalias *, struct alias_link *, int); static int GetNewPort(struct libalias *, struct alias_link *, int);
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
static u_short GetSocket(struct libalias *, u_short, int *, int); static u_short GetSocket(struct libalias *, u_short, int *, int);
#endif #endif
static void CleanupAliasData(struct libalias *); static void CleanupAliasData(struct libalias *);
static void CleanupLink(struct libalias *, struct alias_link **); static void CleanupLink(struct libalias *, struct alias_link **);
static void DeleteLink(struct alias_link **); static void DeleteLink(struct alias_link **);
static struct alias_link *
UseLink(struct libalias *, struct alias_link *);
static struct alias_link * static struct alias_link *
ReLink(struct alias_link *, ReLink(struct alias_link *,
struct in_addr, struct in_addr, struct in_addr, struct in_addr, struct in_addr, struct in_addr,
u_short, u_short, int, int); u_short, u_short, int, int);
static struct alias_link * static struct alias_link *
FindLinkOut(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int); FindLinkOut(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int);
static struct alias_link * static struct alias_link *
FindLinkIn(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int); FindLinkIn(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int);
#define ALIAS_PORT_BASE 0x08000 static u_short _RandomPort(struct libalias *la);
#define ALIAS_PORT_MASK 0x07fff
#define ALIAS_PORT_MASK_EVEN 0x07ffe
#define GET_NEW_PORT_MAX_ATTEMPTS 20 #define GET_NEW_PORT_MAX_ATTEMPTS 20
#define FIND_EVEN_ALIAS_BASE 1 /* get random port in network byte order */
static u_short
_RandomPort(struct libalias *la) {
u_short port;
port = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
return ntohs(port);
}
/* GetNewPort() allocates port numbers. Note that if a port number /* GetNewPort() allocates port numbers. Note that if a port number
is already in use, that does not mean that it cannot be used by is already in use, that does not mean that it cannot be used by
another link concurrently. This is because GetNewPort() looks for another link concurrently. This is because GetNewPort() looks for
unused triplets: (dest addr, dest port, alias port). */ unused triplets: (dest addr, dest port, alias port). */
static int static int
GetNewPort(struct libalias *la, struct alias_link *lnk, int alias_port_param) GetNewPort(struct libalias *la, struct alias_link *lnk, int alias_port_param)
{ {
int i; int i;
int max_trials; int max_trials;
u_short port_sys; u_short port;
u_short port_net;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* /*
* Description of alias_port_param for GetNewPort(). When * Description of alias_port_param for GetNewPort(). When
* this parameter is zero or positive, it precisely specifies * this parameter is zero or positive, it precisely specifies
* the port number. GetNewPort() will return this number * the port number. GetNewPort() will return this number
* without check that it is in use. * without check that it is in use.
*
* The aliasing port is automatically selected by one of
* two methods below:
*
* When this parameter is GET_ALIAS_PORT, it indicates to get * When this parameter is GET_ALIAS_PORT, it indicates to get
* a randomly selected port number. * a randomly selected port number.
*/ */
if (alias_port_param == GET_ALIAS_PORT) { if (alias_port_param >= 0 && alias_port_param < 0x10000) {
/*
* The aliasing port is automatically selected by one of
* two methods below:
*/
max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) {
/*
* When the PKT_ALIAS_SAME_PORTS option is chosen,
* the first try will be the actual source port. If
* this is already in use, the remainder of the
* trials will be random.
*/
port_net = lnk->src_port;
port_sys = ntohs(port_net);
} else if (la->aliasPortLower) {
/* First trial is a random port in the aliasing range. */
port_sys = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
port_net = htons(port_sys);
} else {
/* First trial and all subsequent are random. */
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
port_net = htons(port_sys);
}
} else if (alias_port_param >= 0 && alias_port_param < 0x10000) {
lnk->alias_port = (u_short) alias_port_param; lnk->alias_port = (u_short) alias_port_param;
return (0); return (0);
} else { }
if (alias_port_param != GET_ALIAS_PORT) {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/GetNewPort(): "); fprintf(stderr, "PacketAlias/GetNewPort(): ");
fprintf(stderr, "input parameter error\n"); fprintf(stderr, "input parameter error\n");
#endif #endif
return (-1); return (-1);
} }
max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
/*
* When the PKT_ALIAS_SAME_PORTS option is chosen,
* the first try will be the actual source port. If
* this is already in use, the remainder of the
* trials will be random.
*/
port = (la->packetAliasMode & PKT_ALIAS_SAME_PORTS)
? lnk->src_port
: _RandomPort(la);
/* Port number search */ /* Port number search */
for (i = 0; i < max_trials; i++) { for (i = 0; i < max_trials; i++, port = _RandomPort(la)) {
int go_ahead; struct group_in *grp;
struct alias_link *search_result; struct alias_link *search_result;
search_result = FindLinkIn(la, lnk->dst_addr, lnk->alias_addr, grp = StartPointIn(la, lnk->alias_addr, port, lnk->link_type, 0);
lnk->dst_port, port_net, if (grp == NULL)
lnk->link_type, 0); break;
LIST_FOREACH(search_result, &grp->full, all.in) {
if (lnk->dst_addr.s_addr == search_result->dst_addr.s_addr &&
lnk->dst_port == search_result->dst_port)
break; /* found match */
}
if (search_result == NULL) if (search_result == NULL)
go_ahead = 1; break;
else if (!(lnk->flags & LINK_PARTIALLY_SPECIFIED)
&& (search_result->flags & LINK_PARTIALLY_SPECIFIED))
go_ahead = 1;
else
go_ahead = 0;
if (go_ahead) {
#ifndef NO_USE_SOCKETS
if ((la->packetAliasMode & PKT_ALIAS_USE_SOCKETS)
&& (lnk->flags & LINK_PARTIALLY_SPECIFIED)
&& ((lnk->link_type == LINK_TCP) ||
(lnk->link_type == LINK_UDP))) {
if (GetSocket(la, port_net, &lnk->sockfd, lnk->link_type)) {
lnk->alias_port = port_net;
return (0);
} }
} else {
#endif
lnk->alias_port = port_net;
return (0);
#ifndef NO_USE_SOCKETS
}
#endif
}
if (la->aliasPortLower) {
port_sys = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
port_net = htons(port_sys);
} else {
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
port_net = htons(port_sys);
}
}
if (i >= max_trials) {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/GetNewPort(): "); fprintf(stderr, "PacketAlias/GetNewPort(): ");
fprintf(stderr, "could not find free port\n"); fprintf(stderr, "could not find free port\n");
#endif #endif
return (-1);
}
#ifndef NO_USE_SOCKETS
if ((la->packetAliasMode & PKT_ALIAS_USE_SOCKETS) &&
(lnk->flags & LINK_PARTIALLY_SPECIFIED) &&
((lnk->link_type == LINK_TCP) ||
(lnk->link_type == LINK_UDP))) {
if (!GetSocket(la, port, &lnk->sockfd, lnk->link_type)) {
return (-1); return (-1);
} }
}
#endif
lnk->alias_port = port;
return (0);
}
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
static u_short static u_short
GetSocket(struct libalias *la, u_short port_net, int *sockfd, int link_type) GetSocket(struct libalias *la, u_short port_net, int *sockfd, int link_type)
{ {
int err; int err;
int sock; int sock;
struct sockaddr_in sock_addr; struct sockaddr_in sock_addr;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 LinesFindNewPortGroup(struct libalias *la,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
u_short port_count, u_short port_count,
u_char proto, u_char proto,
u_char align) u_char align)
{ {
int i, j; int i, j;
int max_trials; int max_trials;
u_short port_sys; u_short port;
int link_type; int link_type;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* /*
* Get link_type from protocol * Get link_type from protocol
*/ */
switch (proto) { switch (proto) {
Show All 15 LinesFindNewPortGroup(struct libalias *la,
max_trials = GET_NEW_PORT_MAX_ATTEMPTS; max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) { if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) {
/* /*
* When the ALIAS_SAME_PORTS option is chosen, the first * When the ALIAS_SAME_PORTS option is chosen, the first
* try will be the actual source port. If this is already * try will be the actual source port. If this is already
* in use, the remainder of the trials will be random. * in use, the remainder of the trials will be random.
*/ */
port_sys = ntohs(src_port); port = src_port;
} else { } else {
/* First trial and all subsequent are random. */ port = _RandomPort(la);
if (align == FIND_EVEN_ALIAS_BASE)
port_sys = arc4random() & ALIAS_PORT_MASK_EVEN;
else
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
} }
/* Port number search */ /* Port number search */
for (i = 0; i < max_trials; i++) { for (i = 0; i < max_trials; i++, port = _RandomPort(la)) {
struct alias_link *search_result; struct alias_link *search_result;
for (j = 0; j < port_count; j++) if (align)
port &= htons(0xfffe);
for (j = 0; j < port_count; j++) {
u_short port_j = ntohs(port) + j;
if ((search_result = FindLinkIn(la, dst_addr, if ((search_result = FindLinkIn(la, dst_addr,
alias_addr, dst_port, htons(port_sys + j), alias_addr, dst_port, htons(port_j),
link_type, 0)) != NULL) link_type, 0)) != NULL)
break; break;
}
/* Found a good range, return base */ /* Found a good range, return base */
if (j == port_count) if (j == port_count)
return (htons(port_sys)); return (port);
/* Find a new base to try */
if (align == FIND_EVEN_ALIAS_BASE)
port_sys = arc4random() & ALIAS_PORT_MASK_EVEN;
else
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
} }
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/FindNewPortGroup(): "); fprintf(stderr, "PacketAlias/FindNewPortGroup(): ");
fprintf(stderr, "could not find free port(s)\n"); fprintf(stderr, "could not find free port(s)\n");
#endif #endif
return (0); return (0);
} }
static void static void
CleanupAliasData(struct libalias *la) CleanupAliasData(struct libalias *la)
{ {
struct alias_link *lnk, *lnk_tmp; struct alias_link *lnk, *lnk_tmp;
u_int i;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* permanent entries may stay */ /* permanent entries may stay */
TAILQ_FOREACH_SAFE(lnk, &la->checkExpire, list_expire, lnk_tmp) TAILQ_FOREACH_SAFE(lnk, &la->checkExpire, expire.list, lnk_tmp)
DeleteLink(&lnk); DeleteLink(&lnk);
for (i = 0; i < LINK_TABLE_IN_SIZE; i++) {
struct group_in *grp, *grp_tmp;
LIST_FOREACH_SAFE(grp, &la->groupTableIn[i], group_in, grp_tmp)
if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {
LIST_REMOVE(grp, group_in);
free(grp);
} }
}
}
static void static void
CleanupLink(struct libalias *la, struct alias_link **lnk) CleanupLink(struct libalias *la, struct alias_link **lnk)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
if (lnk == NULL || *lnk == NULL) if (lnk == NULL || *lnk == NULL)
return; return;
if (LibAliasTime - (*lnk)->timestamp > (*lnk)->expire_time) { if (LibAliasTime - (*lnk)->timestamp > (*lnk)->expire.timeout) {
DeleteLink(lnk); DeleteLink(lnk);
if ((*lnk) == NULL) if ((*lnk) == NULL)
return; return;
} }
/* move to end, swap may fail on a single entry list */ /* move to end, swap may fail on a single entry list */
TAILQ_REMOVE(&la->checkExpire, (*lnk), list_expire); TAILQ_REMOVE(&la->checkExpire, (*lnk), expire.list);
TAILQ_INSERT_TAIL(&la->checkExpire, (*lnk), list_expire); TAILQ_INSERT_TAIL(&la->checkExpire, (*lnk), expire.list);
} }
static struct alias_link *
UseLink(struct libalias *la, struct alias_link *lnk)
{
CleanupLink(la, &lnk);
if (lnk != NULL)
lnk->timestamp = LibAliasTime;
return (lnk);
}
static void static void
DeleteLink(struct alias_link **plnk) DeleteLink(struct alias_link **plnk)
{ {
struct alias_link *lnk = *plnk; struct alias_link *lnk = *plnk;
struct libalias *la = lnk->la; struct libalias *la = lnk->la;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* Don't do anything if the link is marked permanent */ /* Don't do anything if the link is marked permanent */
if (la->deleteAllLinks == 0 && lnk->flags & LINK_PERMANENT) if (la->deleteAllLinks == 0 && lnk->flags & LINK_PERMANENT)
return; return;
#ifndef NO_FW_PUNCH #ifndef NO_FW_PUNCH
/* Delete associated firewall hole, if any */ /* Delete associated firewall hole, if any */
ClearFWHole(lnk); ClearFWHole(lnk);
#endif #endif
switch (lnk->link_type) {
case LINK_PPTP:
LIST_REMOVE(lnk, pptp.list);
break;
default:
/* Free memory allocated for LSNAT server pool */ /* Free memory allocated for LSNAT server pool */
if (lnk->server != NULL) { if (lnk->server != NULL) {
struct server *head, *curr, *next; struct server *head, *curr, *next;
head = curr = lnk->server; head = curr = lnk->server;
do { do {
next = curr->next; next = curr->next;
free(curr); free(curr);
} while ((curr = next) != head); } while ((curr = next) != head);
} } else {
/* Adjust output table pointers */ /* Adjust output table pointers */
LIST_REMOVE(lnk, list_out); LIST_REMOVE(lnk, all.out);
}
/* Adjust input table pointers */ /* Adjust input table pointers */
LIST_REMOVE(lnk, list_in); LIST_REMOVE(lnk, all.in);
break;
}
/* remove from housekeeping */ /* remove from housekeeping */
TAILQ_REMOVE(&la->checkExpire, lnk, list_expire); TAILQ_REMOVE(&la->checkExpire, lnk, expire.list);
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
/* Close socket, if one has been allocated */ /* Close socket, if one has been allocated */
if (lnk->sockfd != -1) { if (lnk->sockfd != -1) {
la->sockCount--; la->sockCount--;
close(lnk->sockfd); close(lnk->sockfd);
} }
#endif #endif
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
AddLink(struct libalias *la, struct in_addr src_addr, struct in_addr dst_addr, AddLink(struct libalias *la, struct in_addr src_addr, struct in_addr dst_addr,
struct in_addr alias_addr, u_short src_port, u_short dst_port, struct in_addr alias_addr, u_short src_port, u_short dst_port,
int alias_port_param, int link_type) int alias_port_param, int link_type)
{ {
u_int start_point; u_int start_point;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = malloc(sizeof(struct alias_link)); lnk = malloc(sizeof(struct alias_link));
if (lnk != NULL) { if (lnk == NULL) {
#ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink(): ");
fprintf(stderr, "malloc() call failed.\n");
#endif
return (NULL);
}
/* Basic initialization */ /* Basic initialization */
lnk->la = la; lnk->la = la;
lnk->src_addr = src_addr; lnk->src_addr = src_addr;
lnk->dst_addr = dst_addr; lnk->dst_addr = dst_addr;
lnk->alias_addr = alias_addr; lnk->alias_addr = alias_addr;
lnk->proxy_addr.s_addr = INADDR_ANY; lnk->proxy_addr.s_addr = INADDR_ANY;
lnk->src_port = src_port; lnk->src_port = src_port;
lnk->dst_port = dst_port; lnk->dst_port = dst_port;
lnk->proxy_port = 0; lnk->proxy_port = 0;
lnk->server = NULL; lnk->server = NULL;
lnk->link_type = link_type; lnk->link_type = link_type;
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
lnk->sockfd = -1; lnk->sockfd = -1;
#endif #endif
lnk->flags = 0; lnk->flags = 0;
lnk->pflags = 0; lnk->pflags = 0;
lnk->timestamp = LibAliasTime; lnk->timestamp = LibAliasTime;
/* Expiration time */ /* Expiration time */
switch (link_type) { switch (link_type) {
case LINK_ICMP: case LINK_ICMP:
lnk->expire_time = ICMP_EXPIRE_TIME; lnk->expire.timeout = ICMP_EXPIRE_TIME;
break; break;
case LINK_UDP: case LINK_UDP:
lnk->expire_time = UDP_EXPIRE_TIME; lnk->expire.timeout = UDP_EXPIRE_TIME;
break; break;
case LINK_TCP: case LINK_TCP:
lnk->expire_time = TCP_EXPIRE_INITIAL; lnk->expire.timeout = TCP_EXPIRE_INITIAL;
break; break;
case LINK_PPTP:
lnk->flags |= LINK_PERMANENT; /* no timeout. */
break;
case LINK_FRAGMENT_ID: case LINK_FRAGMENT_ID:
lnk->expire_time = FRAGMENT_ID_EXPIRE_TIME; lnk->expire.timeout = FRAGMENT_ID_EXPIRE_TIME;
break; break;
case LINK_FRAGMENT_PTR: case LINK_FRAGMENT_PTR:
lnk->expire_time = FRAGMENT_PTR_EXPIRE_TIME; lnk->expire.timeout = FRAGMENT_PTR_EXPIRE_TIME;
break; break;
case LINK_ADDR: case LINK_ADDR:
break; break;
default: default:
lnk->expire_time = PROTO_EXPIRE_TIME; lnk->expire.timeout = PROTO_EXPIRE_TIME;
break; break;
} }
/* Determine alias flags */ /* Determine alias flags */
if (dst_addr.s_addr == INADDR_ANY) if (dst_addr.s_addr == INADDR_ANY)
lnk->flags |= LINK_UNKNOWN_DEST_ADDR; lnk->flags |= LINK_UNKNOWN_DEST_ADDR;
if (dst_port == 0) if (dst_port == 0)
lnk->flags |= LINK_UNKNOWN_DEST_PORT; lnk->flags |= LINK_UNKNOWN_DEST_PORT;
/* Determine alias port */ /* Determine alias port */
if (GetNewPort(la, lnk, alias_port_param) != 0) { if (GetNewPort(la, lnk, alias_port_param) != 0) {
free(lnk); free(lnk);
return (NULL); return (NULL);
} }
/* Link-type dependent initialization */ /* Link-type dependent initialization */
switch (link_type) { switch (link_type) {
struct tcp_dat *aux_tcp;
case LINK_ICMP: case LINK_ICMP:
la->icmpLinkCount++; la->icmpLinkCount++;
break; break;
case LINK_UDP: case LINK_UDP:
la->udpLinkCount++; la->udpLinkCount++;
break; break;
case LINK_TCP: case LINK_TCP: {
struct tcp_dat *aux_tcp;
int i;
aux_tcp = malloc(sizeof(struct tcp_dat)); aux_tcp = malloc(sizeof(struct tcp_dat));
if (aux_tcp != NULL) { if (aux_tcp != NULL) {
int i; #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink: ");
fprintf(stderr, " cannot allocate auxiliary TCP data\n");
#endif
free(lnk);
return (NULL);
}
la->tcpLinkCount++; la->tcpLinkCount++;
aux_tcp->state.in = ALIAS_TCP_STATE_NOT_CONNECTED; aux_tcp->state.in = ALIAS_TCP_STATE_NOT_CONNECTED;
aux_tcp->state.out = ALIAS_TCP_STATE_NOT_CONNECTED; aux_tcp->state.out = ALIAS_TCP_STATE_NOT_CONNECTED;
aux_tcp->state.index = 0; aux_tcp->state.index = 0;
aux_tcp->state.ack_modified = 0; aux_tcp->state.ack_modified = 0;
for (i = 0; i < N_LINK_TCP_DATA; i++) for (i = 0; i < N_LINK_TCP_DATA; i++)
aux_tcp->ack[i].active = 0; aux_tcp->ack[i].active = 0;
aux_tcp->fwhole = -1; aux_tcp->fwhole = -1;
lnk->data.tcp = aux_tcp; lnk->data.tcp = aux_tcp;
} else {
#ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink: ");
fprintf(stderr, " cannot allocate auxiliary TCP data\n");
#endif
free(lnk);
return (NULL);
} }
break; break;
case LINK_PPTP: case LINK_PPTP:
la->pptpLinkCount++; la->pptpLinkCount++;
break; break;
case LINK_FRAGMENT_ID: case LINK_FRAGMENT_ID:
la->fragmentIdLinkCount++; la->fragmentIdLinkCount++;
break; break;
case LINK_FRAGMENT_PTR: case LINK_FRAGMENT_PTR:
la->fragmentPtrLinkCount++; la->fragmentPtrLinkCount++;
break; break;
case LINK_ADDR: case LINK_ADDR:
break; break;
default: default:
la->protoLinkCount++; la->protoLinkCount++;
break; break;
} }
switch (link_type) {
case LINK_PPTP:
LIST_INSERT_HEAD(&la->pptpTable, lnk, pptp.list);
break;
default: {
struct group_in *grp;
grp = StartPointIn(la, alias_addr, lnk->alias_port, link_type, 1);
if (grp == NULL) {
free(lnk);
return (NULL);
}
/* Set up pointers for output lookup table */ /* Set up pointers for output lookup table */
start_point = StartPointOut(src_addr, dst_addr, start_point = StartPointOut(src_addr, dst_addr,
src_port, dst_port, link_type); src_port, dst_port, link_type);
LIST_INSERT_HEAD(&la->linkTableOut[start_point], lnk, list_out); LIST_INSERT_HEAD(&la->linkTableOut[start_point], lnk, all.out);
/* Set up pointers for input lookup table */ /* Set up pointers for input lookup table */
start_point = StartPointIn(alias_addr, lnk->alias_port, link_type); if (lnk->flags & LINK_PARTIALLY_SPECIFIED)
LIST_INSERT_HEAD(&la->linkTableIn[start_point], lnk, list_in); LIST_INSERT_HEAD(&grp->partial, lnk, all.in);
else
LIST_INSERT_HEAD(&grp->full, lnk, all.in);
}
break;
}
/* Include the element into the housekeeping list */ /* Include the element into the housekeeping list */
TAILQ_INSERT_TAIL(&la->checkExpire, lnk, list_expire); TAILQ_INSERT_TAIL(&la->checkExpire, lnk, expire.list);
} else {
#ifdef LIBALIAS_DEBUG if (la->packetAliasMode & PKT_ALIAS_LOG)
fprintf(stderr, "PacketAlias/AddLink(): ");
fprintf(stderr, "malloc() call failed.\n");
#endif
}
if (la->packetAliasMode & PKT_ALIAS_LOG) {
ShowAliasStats(la); ShowAliasStats(la);
}
return (lnk); return (lnk);
} }
/* /*
* If alias_port_param is less than zero, alias port will be automatically * If alias_port_param is less than zero, alias port will be automatically
* chosen. If greater than zero, equal to alias port * chosen. If greater than zero, equal to alias port
*/ */
static struct alias_link * static struct alias_link *
Show All 19 Lines if (new_lnk != NULL &&
old_lnk->data.tcp->fwhole > 0) { old_lnk->data.tcp->fwhole > 0) {
PunchFWHole(new_lnk); PunchFWHole(new_lnk);
} }
#endif #endif
DeleteLink(&old_lnk); DeleteLink(&old_lnk);
return (new_lnk); return (new_lnk);
} }
#define OUTGUARD \
if (lnk->src_port != src_port || \
lnk->src_addr.s_addr != src_addr.s_addr || \
lnk->dst_addr.s_addr != dst_addr.s_addr || \
lnk->dst_port != dst_port || \
lnk->link_type != link_type) \
continue;
static struct alias_link * static struct alias_link *
_SearchLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr,
u_short src_port,
u_short dst_port,
int link_type) {
u_int i;
struct alias_link *lnk;
i = StartPointOut(src_addr, dst_addr, src_port, dst_port, link_type);
LIST_FOREACH(lnk, &la->linkTableOut[i], all.out) {
OUTGUARD;
return (UseLink(la, lnk));
}
return (NULL);
}
#undef OUTGUARD
static struct alias_link *
_FindLinkOut(struct libalias *la, struct in_addr src_addr, _FindLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
int link_type, int link_type,
int replace_partial_links) int replace_partial_links)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, src_port, dst_port, link_type); lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, dst_port, link_type);
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) { if (lnk != NULL || !replace_partial_links)
if (lnk->dst_addr.s_addr == dst_addr.s_addr && return (lnk);
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->src_port == src_port &&
lnk->dst_port == dst_port &&
lnk->link_type == link_type &&
lnk->server == NULL)
break;
}
CleanupLink(la, &lnk);
if (lnk != NULL)
lnk->timestamp = LibAliasTime;
/* Search for partially specified links. */ /* Search for partially specified links. */
if (lnk == NULL && replace_partial_links) {
if (dst_port != 0 && dst_addr.s_addr != INADDR_ANY) { if (dst_port != 0 && dst_addr.s_addr != INADDR_ANY) {
lnk = _FindLinkOut(la, src_addr, dst_addr, src_port, 0, lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, 0,
link_type, 0); link_type);
if (lnk == NULL) if (lnk == NULL)
lnk = _FindLinkOut(la, src_addr, NO_ADDR, src_port, lnk = _SearchLinkOut(la, src_addr, ANY_ADDR, src_port,
dst_port, link_type, 0); dst_port, link_type);
} }
if (lnk == NULL && if (lnk == NULL &&
(dst_port != 0 || dst_addr.s_addr != INADDR_ANY)) { (dst_port != 0 || dst_addr.s_addr != INADDR_ANY)) {
lnk = _FindLinkOut(la, src_addr, NO_ADDR, src_port, 0, lnk = _SearchLinkOut(la, src_addr, ANY_ADDR, src_port, 0,
link_type, 0); link_type);
} }
if (lnk != NULL) { if (lnk != NULL) {
lnk = ReLink(lnk, lnk = ReLink(lnk,
src_addr, dst_addr, lnk->alias_addr, src_addr, dst_addr, lnk->alias_addr,
src_port, dst_port, lnk->alias_port, src_port, dst_port, lnk->alias_port,
link_type); link_type);
} }
}
return (lnk); return (lnk);
} }
static struct alias_link * static struct alias_link *
FindLinkOut(struct libalias *la, struct in_addr src_addr, FindLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
Show All 10 Lines if (lnk == NULL) {
/* /*
* The following allows permanent links to be specified as * The following allows permanent links to be specified as
* using the default source address (i.e. device interface * using the default source address (i.e. device interface
* address) without knowing in advance what that address * address) without knowing in advance what that address
* is. * is.
*/ */
if (la->aliasAddress.s_addr != INADDR_ANY && if (la->aliasAddress.s_addr != INADDR_ANY &&
src_addr.s_addr == la->aliasAddress.s_addr) { src_addr.s_addr == la->aliasAddress.s_addr) {
lnk = _FindLinkOut(la, NO_ADDR, dst_addr, src_port, dst_port, lnk = _FindLinkOut(la, ANY_ADDR, dst_addr, src_port, dst_port,
link_type, replace_partial_links); link_type, replace_partial_links);
} }
} }
return (lnk); return (lnk);
} }
static struct alias_link * static struct alias_link *
_FindLinkIn(struct libalias *la, struct in_addr dst_addr, _FindLinkIn(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_short dst_port, u_short dst_port,
u_short alias_port, u_short alias_port,
int link_type, int link_type,
int replace_partial_links) int replace_partial_links)
{ {
int flags_in; int flags_in;
u_int start_point; struct group_in *grp;
struct alias_link *lnk; struct alias_link *lnk;
struct alias_link *lnk_fully_specified;
struct alias_link *lnk_unknown_all; struct alias_link *lnk_unknown_all;
struct alias_link *lnk_unknown_dst_addr; struct alias_link *lnk_unknown_dst_addr;
struct alias_link *lnk_unknown_dst_port; struct alias_link *lnk_unknown_dst_port;
struct in_addr src_addr;
u_short src_port;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* Initialize pointers */ /* Initialize pointers */
lnk_fully_specified = NULL;
lnk_unknown_all = NULL; lnk_unknown_all = NULL;
lnk_unknown_dst_addr = NULL; lnk_unknown_dst_addr = NULL;
lnk_unknown_dst_port = NULL; lnk_unknown_dst_port = NULL;
/* If either the dest addr or port is unknown, the search /* If either the dest addr or port is unknown, the search
* loop will have to know about this. */ * loop will have to know about this. */
flags_in = 0; flags_in = 0;
if (dst_addr.s_addr == INADDR_ANY) if (dst_addr.s_addr == INADDR_ANY)
flags_in |= LINK_UNKNOWN_DEST_ADDR; flags_in |= LINK_UNKNOWN_DEST_ADDR;
if (dst_port == 0) if (dst_port == 0)
flags_in |= LINK_UNKNOWN_DEST_PORT; flags_in |= LINK_UNKNOWN_DEST_PORT;
/* Search loop */ /* Search loop */
start_point = StartPointIn(alias_addr, alias_port, link_type); grp = StartPointIn(la, alias_addr, alias_port, link_type, 0);
LIST_FOREACH(lnk, &la->linkTableIn[start_point], list_in) { if (grp == NULL)
int flags; return (NULL);
flags = flags_in | lnk->flags; switch (flags_in) {
if (!(flags & LINK_PARTIALLY_SPECIFIED)) { case 0:
if (lnk->alias_addr.s_addr == alias_addr.s_addr LIST_FOREACH(lnk, &grp->full, all.in) {
&& lnk->alias_port == alias_port if (lnk->dst_addr.s_addr == dst_addr.s_addr &&
&& lnk->dst_addr.s_addr == dst_addr.s_addr lnk->dst_port == dst_port)
&& lnk->dst_port == dst_port return (UseLink(la, lnk));
&& lnk->link_type == link_type) { }
lnk_fully_specified = lnk;
break; break;
case LINK_UNKNOWN_DEST_PORT:
LIST_FOREACH(lnk, &grp->full, all.in) {
if(lnk->dst_addr.s_addr == dst_addr.s_addr) {
lnk_unknown_dst_port = lnk;
break;
} }
} else if ((flags & LINK_UNKNOWN_DEST_ADDR)
&& (flags & LINK_UNKNOWN_DEST_PORT)) {
if (lnk->alias_addr.s_addr == alias_addr.s_addr
&& lnk->alias_port == alias_port
&& lnk->link_type == link_type) {
if (lnk_unknown_all == NULL)
lnk_unknown_all = lnk;
} }
} else if (flags & LINK_UNKNOWN_DEST_ADDR) { break;
if (lnk->alias_addr.s_addr == alias_addr.s_addr case LINK_UNKNOWN_DEST_ADDR:
&& lnk->alias_port == alias_port LIST_FOREACH(lnk, &grp->full, all.in) {
&& lnk->link_type == link_type if(lnk->dst_port == dst_port) {
&& lnk->dst_port == dst_port) {
if (lnk_unknown_dst_addr == NULL)
lnk_unknown_dst_addr = lnk; lnk_unknown_dst_addr = lnk;
break;
} }
} else if (flags & LINK_UNKNOWN_DEST_PORT) { }
if (lnk->alias_addr.s_addr == alias_addr.s_addr break;
&& lnk->alias_port == alias_port case LINK_PARTIALLY_SPECIFIED:
&& lnk->link_type == link_type lnk_unknown_all = LIST_FIRST(&grp->full);
&& lnk->dst_addr.s_addr == dst_addr.s_addr) { break;
if (lnk_unknown_dst_port == NULL) }
if (lnk_unknown_dst_port == NULL) {
LIST_FOREACH(lnk, &grp->partial, all.in) {
int flags = (flags_in | lnk->flags) & LINK_PARTIALLY_SPECIFIED;
if (flags == LINK_PARTIALLY_SPECIFIED &&
lnk_unknown_all == NULL)
lnk_unknown_all = lnk;
if (flags == LINK_UNKNOWN_DEST_ADDR &&
lnk->dst_port == dst_port &&
lnk_unknown_dst_addr == NULL)
lnk_unknown_dst_addr = lnk;
if (flags == LINK_UNKNOWN_DEST_PORT &&
lnk->dst_addr.s_addr == dst_addr.s_addr) {
lnk_unknown_dst_port = lnk; lnk_unknown_dst_port = lnk;
break;
} }
} }
} }
CleanupLink(la, &lnk_fully_specified); lnk = (lnk_unknown_dst_port != NULL) ? lnk_unknown_dst_port
if (lnk_fully_specified != NULL) { : (lnk_unknown_dst_addr != NULL) ? lnk_unknown_dst_addr
lnk_fully_specified->timestamp = LibAliasTime; : lnk_unknown_all;
lnk = lnk_fully_specified;
} else if (lnk_unknown_dst_port != NULL)
lnk = lnk_unknown_dst_port;
else if (lnk_unknown_dst_addr != NULL)
lnk = lnk_unknown_dst_addr;
else if (lnk_unknown_all != NULL)
lnk = lnk_unknown_all;
else
return (NULL);
if (replace_partial_links && if (lnk == NULL || !replace_partial_links)
(lnk->flags & LINK_PARTIALLY_SPECIFIED || lnk->server != NULL)) { return (lnk);
struct in_addr src_addr;
u_short src_port;
if (lnk->server != NULL) { /* LSNAT link */ if (lnk->server != NULL) { /* LSNAT link */
src_addr = lnk->server->addr; src_addr = lnk->server->addr;
src_port = lnk->server->port; src_port = lnk->server->port;
lnk->server = lnk->server->next; lnk->server = lnk->server->next;
} else { } else {
src_addr = lnk->src_addr; src_addr = lnk->src_addr;
src_port = lnk->src_port; src_port = lnk->src_port;
} }
if (link_type == LINK_SCTP) { if (link_type == LINK_SCTP) {
lnk->src_addr = src_addr; lnk->src_addr = src_addr;
lnk->src_port = src_port; lnk->src_port = src_port;
return (lnk); } else {
}
lnk = ReLink(lnk, lnk = ReLink(lnk,
src_addr, dst_addr, alias_addr, src_addr, dst_addr, alias_addr,
src_port, dst_port, alias_port, src_port, dst_port, alias_port,
link_type); link_type);
} }
return (lnk); return (lnk);
} }
Show All 15 Lines if (lnk == NULL) {
/* /*
* The following allows permanent links to be specified as * The following allows permanent links to be specified as
* using the default aliasing address (i.e. device * using the default aliasing address (i.e. device
* interface address) without knowing in advance what that * interface address) without knowing in advance what that
* address is. * address is.
*/ */
if (la->aliasAddress.s_addr != INADDR_ANY && if (la->aliasAddress.s_addr != INADDR_ANY &&
alias_addr.s_addr == la->aliasAddress.s_addr) { alias_addr.s_addr == la->aliasAddress.s_addr) {
lnk = _FindLinkIn(la, dst_addr, NO_ADDR, dst_port, alias_port, lnk = _FindLinkIn(la, dst_addr, ANY_ADDR, dst_port, alias_port,
link_type, replace_partial_links); link_type, replace_partial_links);
} }
} }
return (lnk); return (lnk);
} }
/* External routines for finding/adding links /* External routines for finding/adding links
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 LinesFindFragmentIn1(struct libalias *la, struct in_addr dst_addr,
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, dst_addr, alias_addr, lnk = FindLinkIn(la, dst_addr, alias_addr,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID, 0); LINK_FRAGMENT_ID, 0);
if (lnk == NULL) { if (lnk == NULL) {
lnk = AddLink(la, NO_ADDR, dst_addr, alias_addr, lnk = AddLink(la, ANY_ADDR, dst_addr, alias_addr,
NO_SRC_PORT, NO_DEST_PORT, ip_id, NO_SRC_PORT, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID); LINK_FRAGMENT_ID);
} }
return (lnk); return (lnk);
} }
/* Doesn't add a link if one is not found. */ /* Doesn't add a link if one is not found. */
struct alias_link * struct alias_link *
FindFragmentIn2(struct libalias *la, struct in_addr dst_addr, FindFragmentIn2(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, u_short ip_id) struct in_addr alias_addr, u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return FindLinkIn(la, dst_addr, alias_addr, return FindLinkIn(la, dst_addr, alias_addr,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID, 0); LINK_FRAGMENT_ID, 0);
} }
struct alias_link * struct alias_link *
AddFragmentPtrLink(struct libalias *la, struct in_addr dst_addr, AddFragmentPtrLink(struct libalias *la, struct in_addr dst_addr,
u_short ip_id) u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return AddLink(la, NO_ADDR, dst_addr, NO_ADDR, return AddLink(la, ANY_ADDR, dst_addr, ANY_ADDR,
NO_SRC_PORT, NO_DEST_PORT, ip_id, NO_SRC_PORT, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_PTR); LINK_FRAGMENT_PTR);
} }
struct alias_link * struct alias_link *
FindFragmentPtr(struct libalias *la, struct in_addr dst_addr, FindFragmentPtr(struct libalias *la, struct in_addr dst_addr,
u_short ip_id) u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return FindLinkIn(la, dst_addr, NO_ADDR, return FindLinkIn(la, dst_addr, ANY_ADDR,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_PTR, 0); LINK_FRAGMENT_PTR, 0);
} }
struct alias_link * struct alias_link *
FindProtoIn(struct libalias *la, struct in_addr dst_addr, FindProtoIn(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_char proto) u_char proto)
▲ Show 20 Lines • Show All 131 Lines • ▼ Show 20 LinesAddPptp(struct libalias *la, struct in_addr src_addr,
return (lnk); return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpOutByCallId(struct libalias *la, struct in_addr src_addr, FindPptpOutByCallId(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_int16_t src_call_id) u_int16_t src_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, 0, 0, LINK_PPTP); LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) if (lnk->src_addr.s_addr == src_addr.s_addr &&
if (lnk->link_type == LINK_PPTP &&
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->src_port == src_call_id) lnk->src_port == src_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpOutByPeerCallId(struct libalias *la, struct in_addr src_addr, FindPptpOutByPeerCallId(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_int16_t dst_call_id) u_int16_t dst_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, 0, 0, LINK_PPTP); LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) if (lnk->src_addr.s_addr == src_addr.s_addr &&
if (lnk->link_type == LINK_PPTP &&
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->dst_port == dst_call_id) lnk->dst_port == dst_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpInByCallId(struct libalias *la, struct in_addr dst_addr, FindPptpInByCallId(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_int16_t dst_call_id) u_int16_t dst_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointIn(alias_addr, 0, LINK_PPTP);
LIST_FOREACH(lnk, &la->linkTableIn[i], list_in) LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
if (lnk->link_type == LINK_PPTP && if (lnk->dst_port == dst_call_id &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->alias_addr.s_addr == alias_addr.s_addr && lnk->alias_addr.s_addr == alias_addr.s_addr)
lnk->dst_port == dst_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpInByPeerCallId(struct libalias *la, struct in_addr dst_addr, FindPptpInByPeerCallId(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_int16_t alias_call_id) u_int16_t alias_call_id)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, dst_addr, alias_addr, LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
0 /* any */ , alias_call_id, if (lnk->alias_port == alias_call_id &&
LINK_PPTP, 0); lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->alias_addr.s_addr == alias_addr.s_addr)
break;
return (lnk); return (lnk);
} }
struct alias_link * struct alias_link *
FindRtspOut(struct libalias *la, struct in_addr src_addr, FindRtspOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
Show All 30 Lines
} }
struct in_addr struct in_addr
FindOriginalAddress(struct libalias *la, struct in_addr alias_addr) FindOriginalAddress(struct libalias *la, struct in_addr alias_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, NO_ADDR, alias_addr, lnk = FindLinkIn(la, ANY_ADDR, alias_addr,
0, 0, LINK_ADDR, 0); 0, 0, LINK_ADDR, 0);
if (lnk == NULL) { if (lnk == NULL) {
la->newDefaultLink = 1; la->newDefaultLink = 1;
if (la->targetAddress.s_addr == INADDR_ANY) if (la->targetAddress.s_addr == INADDR_ANY)
return (alias_addr); return (alias_addr);
else if (la->targetAddress.s_addr == INADDR_NONE) else if (la->targetAddress.s_addr == INADDR_NONE)
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : alias_addr; la->aliasAddress : alias_addr;
Show All 15 Lines
} }
struct in_addr struct in_addr
FindAliasAddress(struct libalias *la, struct in_addr original_addr) FindAliasAddress(struct libalias *la, struct in_addr original_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkOut(la, original_addr, NO_ADDR, lnk = FindLinkOut(la, original_addr, ANY_ADDR,
0, 0, LINK_ADDR, 0); 0, 0, LINK_ADDR, 0);
if (lnk == NULL) { if (lnk == NULL) {
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : original_addr; la->aliasAddress : original_addr;
} else { } else {
if (lnk->alias_addr.s_addr == INADDR_ANY) if (lnk->alias_addr.s_addr == INADDR_ANY)
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : original_addr; la->aliasAddress : original_addr;
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
void void
SetStateIn(struct alias_link *lnk, int state) SetStateIn(struct alias_link *lnk, int state)
{ {
/* TCP input state */ /* TCP input state */
switch (state) { switch (state) {
case ALIAS_TCP_STATE_DISCONNECTED: case ALIAS_TCP_STATE_DISCONNECTED:
if (lnk->data.tcp->state.out != ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.out != ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_DEAD; lnk->expire.timeout = TCP_EXPIRE_DEAD;
else else
lnk->expire_time = TCP_EXPIRE_SINGLEDEAD; lnk->expire.timeout = TCP_EXPIRE_SINGLEDEAD;
break; break;
case ALIAS_TCP_STATE_CONNECTED: case ALIAS_TCP_STATE_CONNECTED:
if (lnk->data.tcp->state.out == ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.out == ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_CONNECTED; lnk->expire.timeout = TCP_EXPIRE_CONNECTED;
break; break;
default: default:
#ifdef _KERNEL #ifdef _KERNEL
panic("libalias:SetStateIn() unknown state"); panic("libalias:SetStateIn() unknown state");
#else #else
abort(); abort();
#endif #endif
} }
lnk->data.tcp->state.in = state; lnk->data.tcp->state.in = state;
} }
void void
SetStateOut(struct alias_link *lnk, int state) SetStateOut(struct alias_link *lnk, int state)
{ {
/* TCP output state */ /* TCP output state */
switch (state) { switch (state) {
case ALIAS_TCP_STATE_DISCONNECTED: case ALIAS_TCP_STATE_DISCONNECTED:
if (lnk->data.tcp->state.in != ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.in != ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_DEAD; lnk->expire.timeout = TCP_EXPIRE_DEAD;
else else
lnk->expire_time = TCP_EXPIRE_SINGLEDEAD; lnk->expire.timeout = TCP_EXPIRE_SINGLEDEAD;
break; break;
case ALIAS_TCP_STATE_CONNECTED: case ALIAS_TCP_STATE_CONNECTED:
if (lnk->data.tcp->state.in == ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.in == ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_CONNECTED; lnk->expire.timeout = TCP_EXPIRE_CONNECTED;
break; break;
default: default:
#ifdef _KERNEL #ifdef _KERNEL
panic("libalias:SetStateOut() unknown state"); panic("libalias:SetStateOut() unknown state");
#else #else
abort(); abort();
#endif #endif
} }
▲ Show 20 Lines • Show All 232 Lines • ▼ Show 20 Lines
SetExpire(struct alias_link *lnk, int expire) SetExpire(struct alias_link *lnk, int expire)
{ {
if (expire == 0) { if (expire == 0) {
lnk->flags &= ~LINK_PERMANENT; lnk->flags &= ~LINK_PERMANENT;
DeleteLink(&lnk); DeleteLink(&lnk);
} else if (expire == -1) { } else if (expire == -1) {
lnk->flags |= LINK_PERMANENT; lnk->flags |= LINK_PERMANENT;
} else if (expire > 0) { } else if (expire > 0) {
lnk->expire_time = expire; lnk->expire.timeout = expire;
} else { } else {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/SetExpire(): "); fprintf(stderr, "PacketAlias/SetExpire(): ");
fprintf(stderr, "error in expire parameter\n"); fprintf(stderr, "error in expire parameter\n");
#endif #endif
} }
} }
▲ Show 20 Lines • Show All 187 Lines • ▼ Show 20 Lines
LibAliasAddServer(struct libalias *la, struct alias_link *lnk, struct in_addr addr, u_short port) LibAliasAddServer(struct libalias *la, struct alias_link *lnk, struct in_addr addr, u_short port)
{ {
struct server *server; struct server *server;
int res; int res;
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
(void)la; (void)la;
switch (lnk->link_type) {
case LINK_PPTP:
server = NULL;
break;
default:
server = malloc(sizeof(struct server)); server = malloc(sizeof(struct server));
break;
}
if (server != NULL) { if (server != NULL) {
struct server *head; struct server *head;
server->addr = addr; server->addr = addr;
server->port = port; server->port = port;
head = lnk->server; head = lnk->server;
if (head == NULL) if (head == NULL) {
server->next = server; server->next = server;
else { /* not usable for outgoing connections */
LIST_REMOVE(lnk, all.out);
} else {
struct server *s; struct server *s;
for (s = head; s->next != head; s = s->next) for (s = head; s->next != head; s = s->next)
; ;
s->next = server; s->next = server;
server->next = head; server->next = head;
} }
lnk->server = server; lnk->server = server;
Show All 37 Lines
/* Static address translation */ /* Static address translation */
struct alias_link * struct alias_link *
LibAliasRedirectAddr(struct libalias *la, struct in_addr src_addr, LibAliasRedirectAddr(struct libalias *la, struct in_addr src_addr,
struct in_addr alias_addr) struct in_addr alias_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
lnk = AddLink(la, src_addr, NO_ADDR, alias_addr, lnk = AddLink(la, src_addr, ANY_ADDR, alias_addr,
0, 0, 0, 0, 0, 0,
LINK_ADDR); LINK_ADDR);
if (lnk != NULL) { if (lnk != NULL) {
lnk->flags |= LINK_PERMANENT; lnk->flags |= LINK_PERMANENT;
} }
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
else { else {
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines#ifdef _KERNEL
LibAliasTime = time_uptime; LibAliasTime = time_uptime;
#else #else
LibAliasTime = time(NULL); LibAliasTime = time(NULL);
#endif #endif
for (i = 0; i < LINK_TABLE_OUT_SIZE; i++) for (i = 0; i < LINK_TABLE_OUT_SIZE; i++)
LIST_INIT(&la->linkTableOut[i]); LIST_INIT(&la->linkTableOut[i]);
for (i = 0; i < LINK_TABLE_IN_SIZE; i++) for (i = 0; i < LINK_TABLE_IN_SIZE; i++)
LIST_INIT(&la->linkTableIn[i]); LIST_INIT(&la->groupTableIn[i]);
LIST_INIT(&la->pptpTable);
TAILQ_INIT(&la->checkExpire); TAILQ_INIT(&la->checkExpire);
#ifdef _KERNEL #ifdef _KERNEL
AliasSctpInit(la); AliasSctpInit(la);
#endif #endif
LIBALIAS_LOCK_INIT(la); LIBALIAS_LOCK_INIT(la);
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
} else { } else {
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
la->deleteAllLinks = 1; la->deleteAllLinks = 1;
CleanupAliasData(la); CleanupAliasData(la);
la->deleteAllLinks = 0; la->deleteAllLinks = 0;
#ifdef _KERNEL #ifdef _KERNEL
AliasSctpTerm(la); AliasSctpTerm(la);
AliasSctpInit(la); AliasSctpInit(la);
#endif #endif
} }
la->aliasAddress.s_addr = INADDR_ANY; la->aliasAddress.s_addr = INADDR_ANY;
la->targetAddress.s_addr = INADDR_ANY; la->targetAddress.s_addr = INADDR_ANY;
la->aliasPortLower = 0x8000;
la->aliasPortLength = 0x8000;
la->icmpLinkCount = 0; la->icmpLinkCount = 0;
la->udpLinkCount = 0; la->udpLinkCount = 0;
la->tcpLinkCount = 0; la->tcpLinkCount = 0;
la->sctpLinkCount = 0; la->sctpLinkCount = 0;
la->pptpLinkCount = 0; la->pptpLinkCount = 0;
la->protoLinkCount = 0; la->protoLinkCount = 0;
la->fragmentIdLinkCount = 0; la->fragmentIdLinkCount = 0;
▲ Show 20 Lines • Show All 380 Lines • Show Last 20 Lines
View Options

multimedia/libxine/files/patch-ffmpeg3

Show First 20 Lines • Show All 214 Lines • ▼ Show 20 Lines
/* Dummy port number codes used for FindLinkIn/Out() and AddLink(). /* Dummy port number codes used for FindLinkIn/Out() and AddLink().
These constants can be anything except zero, which indicates an These constants can be anything except zero, which indicates an
unknown port number. */ unknown port number. */
#define NO_DEST_PORT 1 #define NO_DEST_PORT 1
#define NO_SRC_PORT 1 #define NO_SRC_PORT 1
/* Dummy address used for FindLinkIn/Out() and AddLink(). /* Matches any/unknown address in FindLinkIn/Out() and AddLink(). */
The value of this variable is never used. */ static struct in_addr const ANY_ADDR = { INADDR_ANY };
static struct in_addr const NO_ADDR;
/* Data Structures /* Data Structures
The fundamental data structure used in this program is The fundamental data structure used in this program is
"struct alias_link". Whenever a TCP connection is made, "struct alias_link". Whenever a TCP connection is made,
a UDP datagram is sent out, or an ICMP echo request is made, a UDP datagram is sent out, or an ICMP echo request is made,
a link record is made (if it has not already been created). a link record is made (if it has not already been created).
The link record is identified by the source address/port The link record is identified by the source address/port
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
/* flag bits */ /* flag bits */
#define LINK_UNKNOWN_DEST_PORT 0x01 #define LINK_UNKNOWN_DEST_PORT 0x01
#define LINK_UNKNOWN_DEST_ADDR 0x02 #define LINK_UNKNOWN_DEST_ADDR 0x02
#define LINK_PERMANENT 0x04 #define LINK_PERMANENT 0x04
#define LINK_PARTIALLY_SPECIFIED 0x03 /* logical-or of first two bits */ #define LINK_PARTIALLY_SPECIFIED 0x03 /* logical-or of first two bits */
#define LINK_UNFIREWALLED 0x08 #define LINK_UNFIREWALLED 0x08
int timestamp; /* Time link was last accessed */ int timestamp; /* Time link was last accessed */
int expire_time; /* Expire time for link */
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
int sockfd; /* socket descriptor */ int sockfd; /* socket descriptor */
#endif #endif
/* Linked list of pointers for input and output lookup tables */ /* Linked list of pointers for input and output lookup tables */
LIST_ENTRY (alias_link) list_out; union {
LIST_ENTRY (alias_link) list_in; struct {
TAILQ_ENTRY (alias_link) list_expire; LIST_ENTRY(alias_link) in;
LIST_ENTRY(alias_link) out;
} all;
struct {
LIST_ENTRY(alias_link) list;
} pptp;
};
struct {
TAILQ_ENTRY(alias_link) list;
int timeout; /* Expire time for link */
} expire;
/* Auxiliary data */ /* Auxiliary data */
union { union {
char *frag_ptr; char *frag_ptr;
struct in_addr frag_addr; struct in_addr frag_addr;
struct tcp_dat *tcp; struct tcp_dat *tcp;
} data; } data;
}; };
Show All 36 Lines StartPointOut() -- link table initial search point for
outgoing packets outgoing packets
Miscellaneous: Miscellaneous:
SeqDiff() -- difference between two TCP sequences SeqDiff() -- difference between two TCP sequences
ShowAliasStats() -- send alias statistics to a monitor file ShowAliasStats() -- send alias statistics to a monitor file
*/ */
/* Local prototypes */ /* Local prototypes */
static u_int StartPointIn(struct in_addr, u_short, int); static struct group_in *
StartPointIn(struct libalias *, struct in_addr, u_short, int, int);
static u_int static u_int
StartPointOut(struct in_addr, struct in_addr, StartPointOut(struct in_addr, struct in_addr, u_short, u_short, int);
u_short, u_short, int);
static int SeqDiff(u_long, u_long); static int SeqDiff(u_long, u_long);
#ifndef NO_FW_PUNCH #ifndef NO_FW_PUNCH
/* Firewall control */ /* Firewall control */
static void InitPunchFW(struct libalias *); static void InitPunchFW(struct libalias *);
static void UninitPunchFW(struct libalias *); static void UninitPunchFW(struct libalias *);
static void ClearFWHole(struct alias_link *); static void ClearFWHole(struct alias_link *);
#endif #endif
/* Log file control */ /* Log file control */
static void ShowAliasStats(struct libalias *); static void ShowAliasStats(struct libalias *);
static int InitPacketAliasLog(struct libalias *); static int InitPacketAliasLog(struct libalias *);
static void UninitPacketAliasLog(struct libalias *); static void UninitPacketAliasLog(struct libalias *);
void SctpShowAliasStats(struct libalias *la); void SctpShowAliasStats(struct libalias *la);
static u_int #define INGUARD \
StartPointIn(struct in_addr alias_addr, if (grp->alias_port != alias_port || \
u_short alias_port, grp->link_type != link_type || \
int link_type) grp->alias_addr.s_addr != alias_addr.s_addr) \
continue;
static struct group_in *
StartPointIn(struct libalias *la,
struct in_addr alias_addr, u_short alias_port, int link_type,
int create)
{ {
u_int n; u_int n;
struct group_in *grp, *tmp;
n = alias_addr.s_addr; n = alias_addr.s_addr;
if (link_type != LINK_PPTP)
n += alias_port; n += alias_port;
n += link_type; n += link_type;
return (n % LINK_TABLE_IN_SIZE); n %= LINK_TABLE_IN_SIZE;
LIST_FOREACH_SAFE(grp, &la->groupTableIn[n], group_in, tmp) {
/* Auto cleanup */
if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {
LIST_REMOVE(grp, group_in);
free(grp);
} else {
INGUARD;
return (grp);
} }
}
if (!create || (grp = malloc(sizeof(*grp))) == NULL)
return (grp);
grp->alias_addr = alias_addr;
grp->alias_port = alias_port;
grp->link_type = link_type;
LIST_INIT(&grp->full);
LIST_INIT(&grp->partial);
LIST_INSERT_HEAD(&la->groupTableIn[n], grp, group_in);
return (grp);
}
#undef INGUARD
static u_int static u_int
StartPointOut(struct in_addr src_addr, struct in_addr dst_addr, StartPointOut(struct in_addr src_addr, struct in_addr dst_addr,
u_short src_port, u_short dst_port, int link_type) u_short src_port, u_short dst_port, int link_type)
{ {
u_int n; u_int n;
n = src_addr.s_addr; n = src_addr.s_addr;
n += dst_addr.s_addr; n += dst_addr.s_addr;
if (link_type != LINK_PPTP) {
n += src_port; n += src_port;
n += dst_port; n += dst_port;
}
n += link_type; n += link_type;
return (n % LINK_TABLE_OUT_SIZE); return (n % LINK_TABLE_OUT_SIZE);
} }
static int static int
SeqDiff(u_long x, u_long y) SeqDiff(u_long x, u_long y)
{ {
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
/* Local prototypes */ /* Local prototypes */
static int GetNewPort(struct libalias *, struct alias_link *, int); static int GetNewPort(struct libalias *, struct alias_link *, int);
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
static u_short GetSocket(struct libalias *, u_short, int *, int); static u_short GetSocket(struct libalias *, u_short, int *, int);
#endif #endif
static void CleanupAliasData(struct libalias *); static void CleanupAliasData(struct libalias *);
static void CleanupLink(struct libalias *, struct alias_link **); static void CleanupLink(struct libalias *, struct alias_link **);
static void DeleteLink(struct alias_link **); static void DeleteLink(struct alias_link **);
static struct alias_link *
UseLink(struct libalias *, struct alias_link *);
static struct alias_link * static struct alias_link *
ReLink(struct alias_link *, ReLink(struct alias_link *,
struct in_addr, struct in_addr, struct in_addr, struct in_addr, struct in_addr, struct in_addr,
u_short, u_short, int, int); u_short, u_short, int, int);
static struct alias_link * static struct alias_link *
FindLinkOut(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int); FindLinkOut(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int);
static struct alias_link * static struct alias_link *
FindLinkIn(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int); FindLinkIn(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int);
#define ALIAS_PORT_BASE 0x08000 static u_short _RandomPort(struct libalias *la);
#define ALIAS_PORT_MASK 0x07fff
#define ALIAS_PORT_MASK_EVEN 0x07ffe
#define GET_NEW_PORT_MAX_ATTEMPTS 20 #define GET_NEW_PORT_MAX_ATTEMPTS 20
#define FIND_EVEN_ALIAS_BASE 1 /* get random port in network byte order */
static u_short
_RandomPort(struct libalias *la) {
u_short port;
port = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
return ntohs(port);
}
/* GetNewPort() allocates port numbers. Note that if a port number /* GetNewPort() allocates port numbers. Note that if a port number
is already in use, that does not mean that it cannot be used by is already in use, that does not mean that it cannot be used by
another link concurrently. This is because GetNewPort() looks for another link concurrently. This is because GetNewPort() looks for
unused triplets: (dest addr, dest port, alias port). */ unused triplets: (dest addr, dest port, alias port). */
static int static int
GetNewPort(struct libalias *la, struct alias_link *lnk, int alias_port_param) GetNewPort(struct libalias *la, struct alias_link *lnk, int alias_port_param)
{ {
int i; int i;
int max_trials; int max_trials;
u_short port_sys; u_short port;
u_short port_net;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* /*
* Description of alias_port_param for GetNewPort(). When * Description of alias_port_param for GetNewPort(). When
* this parameter is zero or positive, it precisely specifies * this parameter is zero or positive, it precisely specifies
* the port number. GetNewPort() will return this number * the port number. GetNewPort() will return this number
* without check that it is in use. * without check that it is in use.
*
* The aliasing port is automatically selected by one of
* two methods below:
*
* When this parameter is GET_ALIAS_PORT, it indicates to get * When this parameter is GET_ALIAS_PORT, it indicates to get
* a randomly selected port number. * a randomly selected port number.
*/ */
if (alias_port_param == GET_ALIAS_PORT) { if (alias_port_param >= 0 && alias_port_param < 0x10000) {
/*
* The aliasing port is automatically selected by one of
* two methods below:
*/
max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) {
/*
* When the PKT_ALIAS_SAME_PORTS option is chosen,
* the first try will be the actual source port. If
* this is already in use, the remainder of the
* trials will be random.
*/
port_net = lnk->src_port;
port_sys = ntohs(port_net);
} else if (la->aliasPortLower) {
/* First trial is a random port in the aliasing range. */
port_sys = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
port_net = htons(port_sys);
} else {
/* First trial and all subsequent are random. */
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
port_net = htons(port_sys);
}
} else if (alias_port_param >= 0 && alias_port_param < 0x10000) {
lnk->alias_port = (u_short) alias_port_param; lnk->alias_port = (u_short) alias_port_param;
return (0); return (0);
} else { }
if (alias_port_param != GET_ALIAS_PORT) {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/GetNewPort(): "); fprintf(stderr, "PacketAlias/GetNewPort(): ");
fprintf(stderr, "input parameter error\n"); fprintf(stderr, "input parameter error\n");
#endif #endif
return (-1); return (-1);
} }
max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
/*
* When the PKT_ALIAS_SAME_PORTS option is chosen,
* the first try will be the actual source port. If
* this is already in use, the remainder of the
* trials will be random.
*/
port = (la->packetAliasMode & PKT_ALIAS_SAME_PORTS)
? lnk->src_port
: _RandomPort(la);
/* Port number search */ /* Port number search */
for (i = 0; i < max_trials; i++) { for (i = 0; i < max_trials; i++, port = _RandomPort(la)) {
int go_ahead; struct group_in *grp;
struct alias_link *search_result; struct alias_link *search_result;
search_result = FindLinkIn(la, lnk->dst_addr, lnk->alias_addr, grp = StartPointIn(la, lnk->alias_addr, port, lnk->link_type, 0);
lnk->dst_port, port_net, if (grp == NULL)
lnk->link_type, 0); break;
LIST_FOREACH(search_result, &grp->full, all.in) {
if (lnk->dst_addr.s_addr == search_result->dst_addr.s_addr &&
lnk->dst_port == search_result->dst_port)
break; /* found match */
}
if (search_result == NULL) if (search_result == NULL)
go_ahead = 1; break;
else if (!(lnk->flags & LINK_PARTIALLY_SPECIFIED)
&& (search_result->flags & LINK_PARTIALLY_SPECIFIED))
go_ahead = 1;
else
go_ahead = 0;
if (go_ahead) {
#ifndef NO_USE_SOCKETS
if ((la->packetAliasMode & PKT_ALIAS_USE_SOCKETS)
&& (lnk->flags & LINK_PARTIALLY_SPECIFIED)
&& ((lnk->link_type == LINK_TCP) ||
(lnk->link_type == LINK_UDP))) {
if (GetSocket(la, port_net, &lnk->sockfd, lnk->link_type)) {
lnk->alias_port = port_net;
return (0);
} }
} else {
#endif
lnk->alias_port = port_net;
return (0);
#ifndef NO_USE_SOCKETS
}
#endif
}
if (la->aliasPortLower) {
port_sys = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
port_net = htons(port_sys);
} else {
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
port_net = htons(port_sys);
}
}
if (i >= max_trials) {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/GetNewPort(): "); fprintf(stderr, "PacketAlias/GetNewPort(): ");
fprintf(stderr, "could not find free port\n"); fprintf(stderr, "could not find free port\n");
#endif #endif
return (-1);
}
#ifndef NO_USE_SOCKETS
if ((la->packetAliasMode & PKT_ALIAS_USE_SOCKETS) &&
(lnk->flags & LINK_PARTIALLY_SPECIFIED) &&
((lnk->link_type == LINK_TCP) ||
(lnk->link_type == LINK_UDP))) {
if (!GetSocket(la, port, &lnk->sockfd, lnk->link_type)) {
return (-1); return (-1);
} }
}
#endif
lnk->alias_port = port;
return (0);
}
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
static u_short static u_short
GetSocket(struct libalias *la, u_short port_net, int *sockfd, int link_type) GetSocket(struct libalias *la, u_short port_net, int *sockfd, int link_type)
{ {
int err; int err;
int sock; int sock;
struct sockaddr_in sock_addr; struct sockaddr_in sock_addr;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 LinesFindNewPortGroup(struct libalias *la,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
u_short port_count, u_short port_count,
u_char proto, u_char proto,
u_char align) u_char align)
{ {
int i, j; int i, j;
int max_trials; int max_trials;
u_short port_sys; u_short port;
int link_type; int link_type;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* /*
* Get link_type from protocol * Get link_type from protocol
*/ */
switch (proto) { switch (proto) {
Show All 15 LinesFindNewPortGroup(struct libalias *la,
max_trials = GET_NEW_PORT_MAX_ATTEMPTS; max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) { if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) {
/* /*
* When the ALIAS_SAME_PORTS option is chosen, the first * When the ALIAS_SAME_PORTS option is chosen, the first
* try will be the actual source port. If this is already * try will be the actual source port. If this is already
* in use, the remainder of the trials will be random. * in use, the remainder of the trials will be random.
*/ */
port_sys = ntohs(src_port); port = src_port;
} else { } else {
/* First trial and all subsequent are random. */ port = _RandomPort(la);
if (align == FIND_EVEN_ALIAS_BASE)
port_sys = arc4random() & ALIAS_PORT_MASK_EVEN;
else
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
} }
/* Port number search */ /* Port number search */
for (i = 0; i < max_trials; i++) { for (i = 0; i < max_trials; i++, port = _RandomPort(la)) {
struct alias_link *search_result; struct alias_link *search_result;
for (j = 0; j < port_count; j++) if (align)
port &= htons(0xfffe);
for (j = 0; j < port_count; j++) {
u_short port_j = ntohs(port) + j;
if ((search_result = FindLinkIn(la, dst_addr, if ((search_result = FindLinkIn(la, dst_addr,
alias_addr, dst_port, htons(port_sys + j), alias_addr, dst_port, htons(port_j),
link_type, 0)) != NULL) link_type, 0)) != NULL)
break; break;
}
/* Found a good range, return base */ /* Found a good range, return base */
if (j == port_count) if (j == port_count)
return (htons(port_sys)); return (port);
/* Find a new base to try */
if (align == FIND_EVEN_ALIAS_BASE)
port_sys = arc4random() & ALIAS_PORT_MASK_EVEN;
else
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
} }
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/FindNewPortGroup(): "); fprintf(stderr, "PacketAlias/FindNewPortGroup(): ");
fprintf(stderr, "could not find free port(s)\n"); fprintf(stderr, "could not find free port(s)\n");
#endif #endif
return (0); return (0);
} }
static void static void
CleanupAliasData(struct libalias *la) CleanupAliasData(struct libalias *la)
{ {
struct alias_link *lnk, *lnk_tmp; struct alias_link *lnk, *lnk_tmp;
u_int i;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* permanent entries may stay */ /* permanent entries may stay */
TAILQ_FOREACH_SAFE(lnk, &la->checkExpire, list_expire, lnk_tmp) TAILQ_FOREACH_SAFE(lnk, &la->checkExpire, expire.list, lnk_tmp)
DeleteLink(&lnk); DeleteLink(&lnk);
for (i = 0; i < LINK_TABLE_IN_SIZE; i++) {
struct group_in *grp, *grp_tmp;
LIST_FOREACH_SAFE(grp, &la->groupTableIn[i], group_in, grp_tmp)
if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {
LIST_REMOVE(grp, group_in);
free(grp);
} }
}
}
static void static void
CleanupLink(struct libalias *la, struct alias_link **lnk) CleanupLink(struct libalias *la, struct alias_link **lnk)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
if (lnk == NULL || *lnk == NULL) if (lnk == NULL || *lnk == NULL)
return; return;
if (LibAliasTime - (*lnk)->timestamp > (*lnk)->expire_time) { if (LibAliasTime - (*lnk)->timestamp > (*lnk)->expire.timeout) {
DeleteLink(lnk); DeleteLink(lnk);
if ((*lnk) == NULL) if ((*lnk) == NULL)
return; return;
} }
/* move to end, swap may fail on a single entry list */ /* move to end, swap may fail on a single entry list */
TAILQ_REMOVE(&la->checkExpire, (*lnk), list_expire); TAILQ_REMOVE(&la->checkExpire, (*lnk), expire.list);
TAILQ_INSERT_TAIL(&la->checkExpire, (*lnk), list_expire); TAILQ_INSERT_TAIL(&la->checkExpire, (*lnk), expire.list);
} }
static struct alias_link *
UseLink(struct libalias *la, struct alias_link *lnk)
{
CleanupLink(la, &lnk);
if (lnk != NULL)
lnk->timestamp = LibAliasTime;
return (lnk);
}
static void static void
DeleteLink(struct alias_link **plnk) DeleteLink(struct alias_link **plnk)
{ {
struct alias_link *lnk = *plnk; struct alias_link *lnk = *plnk;
struct libalias *la = lnk->la; struct libalias *la = lnk->la;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* Don't do anything if the link is marked permanent */ /* Don't do anything if the link is marked permanent */
if (la->deleteAllLinks == 0 && lnk->flags & LINK_PERMANENT) if (la->deleteAllLinks == 0 && lnk->flags & LINK_PERMANENT)
return; return;
#ifndef NO_FW_PUNCH #ifndef NO_FW_PUNCH
/* Delete associated firewall hole, if any */ /* Delete associated firewall hole, if any */
ClearFWHole(lnk); ClearFWHole(lnk);
#endif #endif
switch (lnk->link_type) {
case LINK_PPTP:
LIST_REMOVE(lnk, pptp.list);
break;
default:
/* Free memory allocated for LSNAT server pool */ /* Free memory allocated for LSNAT server pool */
if (lnk->server != NULL) { if (lnk->server != NULL) {
struct server *head, *curr, *next; struct server *head, *curr, *next;
head = curr = lnk->server; head = curr = lnk->server;
do { do {
next = curr->next; next = curr->next;
free(curr); free(curr);
} while ((curr = next) != head); } while ((curr = next) != head);
} } else {
/* Adjust output table pointers */ /* Adjust output table pointers */
LIST_REMOVE(lnk, list_out); LIST_REMOVE(lnk, all.out);
}
/* Adjust input table pointers */ /* Adjust input table pointers */
LIST_REMOVE(lnk, list_in); LIST_REMOVE(lnk, all.in);
break;
}
/* remove from housekeeping */ /* remove from housekeeping */
TAILQ_REMOVE(&la->checkExpire, lnk, list_expire); TAILQ_REMOVE(&la->checkExpire, lnk, expire.list);
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
/* Close socket, if one has been allocated */ /* Close socket, if one has been allocated */
if (lnk->sockfd != -1) { if (lnk->sockfd != -1) {
la->sockCount--; la->sockCount--;
close(lnk->sockfd); close(lnk->sockfd);
} }
#endif #endif
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
AddLink(struct libalias *la, struct in_addr src_addr, struct in_addr dst_addr, AddLink(struct libalias *la, struct in_addr src_addr, struct in_addr dst_addr,
struct in_addr alias_addr, u_short src_port, u_short dst_port, struct in_addr alias_addr, u_short src_port, u_short dst_port,
int alias_port_param, int link_type) int alias_port_param, int link_type)
{ {
u_int start_point; u_int start_point;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = malloc(sizeof(struct alias_link)); lnk = malloc(sizeof(struct alias_link));
if (lnk != NULL) { if (lnk == NULL) {
#ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink(): ");
fprintf(stderr, "malloc() call failed.\n");
#endif
return (NULL);
}
/* Basic initialization */ /* Basic initialization */
lnk->la = la; lnk->la = la;
lnk->src_addr = src_addr; lnk->src_addr = src_addr;
lnk->dst_addr = dst_addr; lnk->dst_addr = dst_addr;
lnk->alias_addr = alias_addr; lnk->alias_addr = alias_addr;
lnk->proxy_addr.s_addr = INADDR_ANY; lnk->proxy_addr.s_addr = INADDR_ANY;
lnk->src_port = src_port; lnk->src_port = src_port;
lnk->dst_port = dst_port; lnk->dst_port = dst_port;
lnk->proxy_port = 0; lnk->proxy_port = 0;
lnk->server = NULL; lnk->server = NULL;
lnk->link_type = link_type; lnk->link_type = link_type;
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
lnk->sockfd = -1; lnk->sockfd = -1;
#endif #endif
lnk->flags = 0; lnk->flags = 0;
lnk->pflags = 0; lnk->pflags = 0;
lnk->timestamp = LibAliasTime; lnk->timestamp = LibAliasTime;
/* Expiration time */ /* Expiration time */
switch (link_type) { switch (link_type) {
case LINK_ICMP: case LINK_ICMP:
lnk->expire_time = ICMP_EXPIRE_TIME; lnk->expire.timeout = ICMP_EXPIRE_TIME;
break; break;
case LINK_UDP: case LINK_UDP:
lnk->expire_time = UDP_EXPIRE_TIME; lnk->expire.timeout = UDP_EXPIRE_TIME;
break; break;
case LINK_TCP: case LINK_TCP:
lnk->expire_time = TCP_EXPIRE_INITIAL; lnk->expire.timeout = TCP_EXPIRE_INITIAL;
break; break;
case LINK_PPTP:
lnk->flags |= LINK_PERMANENT; /* no timeout. */
break;
case LINK_FRAGMENT_ID: case LINK_FRAGMENT_ID:
lnk->expire_time = FRAGMENT_ID_EXPIRE_TIME; lnk->expire.timeout = FRAGMENT_ID_EXPIRE_TIME;
break; break;
case LINK_FRAGMENT_PTR: case LINK_FRAGMENT_PTR:
lnk->expire_time = FRAGMENT_PTR_EXPIRE_TIME; lnk->expire.timeout = FRAGMENT_PTR_EXPIRE_TIME;
break; break;
case LINK_ADDR: case LINK_ADDR:
break; break;
default: default:
lnk->expire_time = PROTO_EXPIRE_TIME; lnk->expire.timeout = PROTO_EXPIRE_TIME;
break; break;
} }
/* Determine alias flags */ /* Determine alias flags */
if (dst_addr.s_addr == INADDR_ANY) if (dst_addr.s_addr == INADDR_ANY)
lnk->flags |= LINK_UNKNOWN_DEST_ADDR; lnk->flags |= LINK_UNKNOWN_DEST_ADDR;
if (dst_port == 0) if (dst_port == 0)
lnk->flags |= LINK_UNKNOWN_DEST_PORT; lnk->flags |= LINK_UNKNOWN_DEST_PORT;
/* Determine alias port */ /* Determine alias port */
if (GetNewPort(la, lnk, alias_port_param) != 0) { if (GetNewPort(la, lnk, alias_port_param) != 0) {
free(lnk); free(lnk);
return (NULL); return (NULL);
} }
/* Link-type dependent initialization */ /* Link-type dependent initialization */
switch (link_type) { switch (link_type) {
struct tcp_dat *aux_tcp;
case LINK_ICMP: case LINK_ICMP:
la->icmpLinkCount++; la->icmpLinkCount++;
break; break;
case LINK_UDP: case LINK_UDP:
la->udpLinkCount++; la->udpLinkCount++;
break; break;
case LINK_TCP: case LINK_TCP: {
struct tcp_dat *aux_tcp;
int i;
aux_tcp = malloc(sizeof(struct tcp_dat)); aux_tcp = malloc(sizeof(struct tcp_dat));
if (aux_tcp != NULL) { if (aux_tcp != NULL) {
int i; #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink: ");
fprintf(stderr, " cannot allocate auxiliary TCP data\n");
#endif
free(lnk);
return (NULL);
}
la->tcpLinkCount++; la->tcpLinkCount++;
aux_tcp->state.in = ALIAS_TCP_STATE_NOT_CONNECTED; aux_tcp->state.in = ALIAS_TCP_STATE_NOT_CONNECTED;
aux_tcp->state.out = ALIAS_TCP_STATE_NOT_CONNECTED; aux_tcp->state.out = ALIAS_TCP_STATE_NOT_CONNECTED;
aux_tcp->state.index = 0; aux_tcp->state.index = 0;
aux_tcp->state.ack_modified = 0; aux_tcp->state.ack_modified = 0;
for (i = 0; i < N_LINK_TCP_DATA; i++) for (i = 0; i < N_LINK_TCP_DATA; i++)
aux_tcp->ack[i].active = 0; aux_tcp->ack[i].active = 0;
aux_tcp->fwhole = -1; aux_tcp->fwhole = -1;
lnk->data.tcp = aux_tcp; lnk->data.tcp = aux_tcp;
} else {
#ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink: ");
fprintf(stderr, " cannot allocate auxiliary TCP data\n");
#endif
free(lnk);
return (NULL);
} }
break; break;
case LINK_PPTP: case LINK_PPTP:
la->pptpLinkCount++; la->pptpLinkCount++;
break; break;
case LINK_FRAGMENT_ID: case LINK_FRAGMENT_ID:
la->fragmentIdLinkCount++; la->fragmentIdLinkCount++;
break; break;
case LINK_FRAGMENT_PTR: case LINK_FRAGMENT_PTR:
la->fragmentPtrLinkCount++; la->fragmentPtrLinkCount++;
break; break;
case LINK_ADDR: case LINK_ADDR:
break; break;
default: default:
la->protoLinkCount++; la->protoLinkCount++;
break; break;
} }
switch (link_type) {
case LINK_PPTP:
LIST_INSERT_HEAD(&la->pptpTable, lnk, pptp.list);
break;
default: {
struct group_in *grp;
grp = StartPointIn(la, alias_addr, lnk->alias_port, link_type, 1);
if (grp == NULL) {
free(lnk);
return (NULL);
}
/* Set up pointers for output lookup table */ /* Set up pointers for output lookup table */
start_point = StartPointOut(src_addr, dst_addr, start_point = StartPointOut(src_addr, dst_addr,
src_port, dst_port, link_type); src_port, dst_port, link_type);
LIST_INSERT_HEAD(&la->linkTableOut[start_point], lnk, list_out); LIST_INSERT_HEAD(&la->linkTableOut[start_point], lnk, all.out);
/* Set up pointers for input lookup table */ /* Set up pointers for input lookup table */
start_point = StartPointIn(alias_addr, lnk->alias_port, link_type); if (lnk->flags & LINK_PARTIALLY_SPECIFIED)
LIST_INSERT_HEAD(&la->linkTableIn[start_point], lnk, list_in); LIST_INSERT_HEAD(&grp->partial, lnk, all.in);
else
LIST_INSERT_HEAD(&grp->full, lnk, all.in);
}
break;
}
/* Include the element into the housekeeping list */ /* Include the element into the housekeeping list */
TAILQ_INSERT_TAIL(&la->checkExpire, lnk, list_expire); TAILQ_INSERT_TAIL(&la->checkExpire, lnk, expire.list);
} else {
#ifdef LIBALIAS_DEBUG if (la->packetAliasMode & PKT_ALIAS_LOG)
fprintf(stderr, "PacketAlias/AddLink(): ");
fprintf(stderr, "malloc() call failed.\n");
#endif
}
if (la->packetAliasMode & PKT_ALIAS_LOG) {
ShowAliasStats(la); ShowAliasStats(la);
}
return (lnk); return (lnk);
} }
/* /*
* If alias_port_param is less than zero, alias port will be automatically * If alias_port_param is less than zero, alias port will be automatically
* chosen. If greater than zero, equal to alias port * chosen. If greater than zero, equal to alias port
*/ */
static struct alias_link * static struct alias_link *
Show All 19 Lines if (new_lnk != NULL &&
old_lnk->data.tcp->fwhole > 0) { old_lnk->data.tcp->fwhole > 0) {
PunchFWHole(new_lnk); PunchFWHole(new_lnk);
} }
#endif #endif
DeleteLink(&old_lnk); DeleteLink(&old_lnk);
return (new_lnk); return (new_lnk);
} }
#define OUTGUARD \
if (lnk->src_port != src_port || \
lnk->src_addr.s_addr != src_addr.s_addr || \
lnk->dst_addr.s_addr != dst_addr.s_addr || \
lnk->dst_port != dst_port || \
lnk->link_type != link_type) \
continue;
static struct alias_link * static struct alias_link *
_SearchLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr,
u_short src_port,
u_short dst_port,
int link_type) {
u_int i;
struct alias_link *lnk;
i = StartPointOut(src_addr, dst_addr, src_port, dst_port, link_type);
LIST_FOREACH(lnk, &la->linkTableOut[i], all.out) {
OUTGUARD;
return (UseLink(la, lnk));
}
return (NULL);
}
#undef OUTGUARD
static struct alias_link *
_FindLinkOut(struct libalias *la, struct in_addr src_addr, _FindLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
int link_type, int link_type,
int replace_partial_links) int replace_partial_links)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, src_port, dst_port, link_type); lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, dst_port, link_type);
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) { if (lnk != NULL || !replace_partial_links)
if (lnk->dst_addr.s_addr == dst_addr.s_addr && return (lnk);
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->src_port == src_port &&
lnk->dst_port == dst_port &&
lnk->link_type == link_type &&
lnk->server == NULL)
break;
}
CleanupLink(la, &lnk);
if (lnk != NULL)
lnk->timestamp = LibAliasTime;
/* Search for partially specified links. */ /* Search for partially specified links. */
if (lnk == NULL && replace_partial_links) {
if (dst_port != 0 && dst_addr.s_addr != INADDR_ANY) { if (dst_port != 0 && dst_addr.s_addr != INADDR_ANY) {
lnk = _FindLinkOut(la, src_addr, dst_addr, src_port, 0, lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, 0,
link_type, 0); link_type);
if (lnk == NULL) if (lnk == NULL)
lnk = _FindLinkOut(la, src_addr, NO_ADDR, src_port, lnk = _SearchLinkOut(la, src_addr, ANY_ADDR, src_port,
dst_port, link_type, 0); dst_port, link_type);
} }
if (lnk == NULL && if (lnk == NULL &&
(dst_port != 0 || dst_addr.s_addr != INADDR_ANY)) { (dst_port != 0 || dst_addr.s_addr != INADDR_ANY)) {
lnk = _FindLinkOut(la, src_addr, NO_ADDR, src_port, 0, lnk = _SearchLinkOut(la, src_addr, ANY_ADDR, src_port, 0,
link_type, 0); link_type);
} }
if (lnk != NULL) { if (lnk != NULL) {
lnk = ReLink(lnk, lnk = ReLink(lnk,
src_addr, dst_addr, lnk->alias_addr, src_addr, dst_addr, lnk->alias_addr,
src_port, dst_port, lnk->alias_port, src_port, dst_port, lnk->alias_port,
link_type); link_type);
} }
}
return (lnk); return (lnk);
} }
static struct alias_link * static struct alias_link *
FindLinkOut(struct libalias *la, struct in_addr src_addr, FindLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
Show All 10 Lines if (lnk == NULL) {
/* /*
* The following allows permanent links to be specified as * The following allows permanent links to be specified as
* using the default source address (i.e. device interface * using the default source address (i.e. device interface
* address) without knowing in advance what that address * address) without knowing in advance what that address
* is. * is.
*/ */
if (la->aliasAddress.s_addr != INADDR_ANY && if (la->aliasAddress.s_addr != INADDR_ANY &&
src_addr.s_addr == la->aliasAddress.s_addr) { src_addr.s_addr == la->aliasAddress.s_addr) {
lnk = _FindLinkOut(la, NO_ADDR, dst_addr, src_port, dst_port, lnk = _FindLinkOut(la, ANY_ADDR, dst_addr, src_port, dst_port,
link_type, replace_partial_links); link_type, replace_partial_links);
} }
} }
return (lnk); return (lnk);
} }
static struct alias_link * static struct alias_link *
_FindLinkIn(struct libalias *la, struct in_addr dst_addr, _FindLinkIn(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_short dst_port, u_short dst_port,
u_short alias_port, u_short alias_port,
int link_type, int link_type,
int replace_partial_links) int replace_partial_links)
{ {
int flags_in; int flags_in;
u_int start_point; struct group_in *grp;
struct alias_link *lnk; struct alias_link *lnk;
struct alias_link *lnk_fully_specified;
struct alias_link *lnk_unknown_all; struct alias_link *lnk_unknown_all;
struct alias_link *lnk_unknown_dst_addr; struct alias_link *lnk_unknown_dst_addr;
struct alias_link *lnk_unknown_dst_port; struct alias_link *lnk_unknown_dst_port;
struct in_addr src_addr;
u_short src_port;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* Initialize pointers */ /* Initialize pointers */
lnk_fully_specified = NULL;
lnk_unknown_all = NULL; lnk_unknown_all = NULL;
lnk_unknown_dst_addr = NULL; lnk_unknown_dst_addr = NULL;
lnk_unknown_dst_port = NULL; lnk_unknown_dst_port = NULL;
/* If either the dest addr or port is unknown, the search /* If either the dest addr or port is unknown, the search
* loop will have to know about this. */ * loop will have to know about this. */
flags_in = 0; flags_in = 0;
if (dst_addr.s_addr == INADDR_ANY) if (dst_addr.s_addr == INADDR_ANY)
flags_in |= LINK_UNKNOWN_DEST_ADDR; flags_in |= LINK_UNKNOWN_DEST_ADDR;
if (dst_port == 0) if (dst_port == 0)
flags_in |= LINK_UNKNOWN_DEST_PORT; flags_in |= LINK_UNKNOWN_DEST_PORT;
/* Search loop */ /* Search loop */
start_point = StartPointIn(alias_addr, alias_port, link_type); grp = StartPointIn(la, alias_addr, alias_port, link_type, 0);
LIST_FOREACH(lnk, &la->linkTableIn[start_point], list_in) { if (grp == NULL)
int flags; return (NULL);
flags = flags_in | lnk->flags; switch (flags_in) {
if (!(flags & LINK_PARTIALLY_SPECIFIED)) { case 0:
if (lnk->alias_addr.s_addr == alias_addr.s_addr LIST_FOREACH(lnk, &grp->full, all.in) {
&& lnk->alias_port == alias_port if (lnk->dst_addr.s_addr == dst_addr.s_addr &&
&& lnk->dst_addr.s_addr == dst_addr.s_addr lnk->dst_port == dst_port)
&& lnk->dst_port == dst_port return (UseLink(la, lnk));
&& lnk->link_type == link_type) { }
lnk_fully_specified = lnk;
break; break;
case LINK_UNKNOWN_DEST_PORT:
LIST_FOREACH(lnk, &grp->full, all.in) {
if(lnk->dst_addr.s_addr == dst_addr.s_addr) {
lnk_unknown_dst_port = lnk;
break;
} }
} else if ((flags & LINK_UNKNOWN_DEST_ADDR)
&& (flags & LINK_UNKNOWN_DEST_PORT)) {
if (lnk->alias_addr.s_addr == alias_addr.s_addr
&& lnk->alias_port == alias_port
&& lnk->link_type == link_type) {
if (lnk_unknown_all == NULL)
lnk_unknown_all = lnk;
} }
} else if (flags & LINK_UNKNOWN_DEST_ADDR) { break;
if (lnk->alias_addr.s_addr == alias_addr.s_addr case LINK_UNKNOWN_DEST_ADDR:
&& lnk->alias_port == alias_port LIST_FOREACH(lnk, &grp->full, all.in) {
&& lnk->link_type == link_type if(lnk->dst_port == dst_port) {
&& lnk->dst_port == dst_port) {
if (lnk_unknown_dst_addr == NULL)
lnk_unknown_dst_addr = lnk; lnk_unknown_dst_addr = lnk;
break;
} }
} else if (flags & LINK_UNKNOWN_DEST_PORT) { }
if (lnk->alias_addr.s_addr == alias_addr.s_addr break;
&& lnk->alias_port == alias_port case LINK_PARTIALLY_SPECIFIED:
&& lnk->link_type == link_type lnk_unknown_all = LIST_FIRST(&grp->full);
&& lnk->dst_addr.s_addr == dst_addr.s_addr) { break;
if (lnk_unknown_dst_port == NULL) }
if (lnk_unknown_dst_port == NULL) {
LIST_FOREACH(lnk, &grp->partial, all.in) {
int flags = (flags_in | lnk->flags) & LINK_PARTIALLY_SPECIFIED;
if (flags == LINK_PARTIALLY_SPECIFIED &&
lnk_unknown_all == NULL)
lnk_unknown_all = lnk;
if (flags == LINK_UNKNOWN_DEST_ADDR &&
lnk->dst_port == dst_port &&
lnk_unknown_dst_addr == NULL)
lnk_unknown_dst_addr = lnk;
if (flags == LINK_UNKNOWN_DEST_PORT &&
lnk->dst_addr.s_addr == dst_addr.s_addr) {
lnk_unknown_dst_port = lnk; lnk_unknown_dst_port = lnk;
break;
} }
} }
} }
CleanupLink(la, &lnk_fully_specified); lnk = (lnk_unknown_dst_port != NULL) ? lnk_unknown_dst_port
if (lnk_fully_specified != NULL) { : (lnk_unknown_dst_addr != NULL) ? lnk_unknown_dst_addr
lnk_fully_specified->timestamp = LibAliasTime; : lnk_unknown_all;
lnk = lnk_fully_specified;
} else if (lnk_unknown_dst_port != NULL)
lnk = lnk_unknown_dst_port;
else if (lnk_unknown_dst_addr != NULL)
lnk = lnk_unknown_dst_addr;
else if (lnk_unknown_all != NULL)
lnk = lnk_unknown_all;
else
return (NULL);
if (replace_partial_links && if (lnk == NULL || !replace_partial_links)
(lnk->flags & LINK_PARTIALLY_SPECIFIED || lnk->server != NULL)) { return (lnk);
struct in_addr src_addr;
u_short src_port;
if (lnk->server != NULL) { /* LSNAT link */ if (lnk->server != NULL) { /* LSNAT link */
src_addr = lnk->server->addr; src_addr = lnk->server->addr;
src_port = lnk->server->port; src_port = lnk->server->port;
lnk->server = lnk->server->next; lnk->server = lnk->server->next;
} else { } else {
src_addr = lnk->src_addr; src_addr = lnk->src_addr;
src_port = lnk->src_port; src_port = lnk->src_port;
} }
if (link_type == LINK_SCTP) { if (link_type == LINK_SCTP) {
lnk->src_addr = src_addr; lnk->src_addr = src_addr;
lnk->src_port = src_port; lnk->src_port = src_port;
return (lnk); } else {
}
lnk = ReLink(lnk, lnk = ReLink(lnk,
src_addr, dst_addr, alias_addr, src_addr, dst_addr, alias_addr,
src_port, dst_port, alias_port, src_port, dst_port, alias_port,
link_type); link_type);
} }
return (lnk); return (lnk);
} }
Show All 15 Lines if (lnk == NULL) {
/* /*
* The following allows permanent links to be specified as * The following allows permanent links to be specified as
* using the default aliasing address (i.e. device * using the default aliasing address (i.e. device
* interface address) without knowing in advance what that * interface address) without knowing in advance what that
* address is. * address is.
*/ */
if (la->aliasAddress.s_addr != INADDR_ANY && if (la->aliasAddress.s_addr != INADDR_ANY &&
alias_addr.s_addr == la->aliasAddress.s_addr) { alias_addr.s_addr == la->aliasAddress.s_addr) {
lnk = _FindLinkIn(la, dst_addr, NO_ADDR, dst_port, alias_port, lnk = _FindLinkIn(la, dst_addr, ANY_ADDR, dst_port, alias_port,
link_type, replace_partial_links); link_type, replace_partial_links);
} }
} }
return (lnk); return (lnk);
} }
/* External routines for finding/adding links /* External routines for finding/adding links
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 LinesFindFragmentIn1(struct libalias *la, struct in_addr dst_addr,
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, dst_addr, alias_addr, lnk = FindLinkIn(la, dst_addr, alias_addr,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID, 0); LINK_FRAGMENT_ID, 0);
if (lnk == NULL) { if (lnk == NULL) {
lnk = AddLink(la, NO_ADDR, dst_addr, alias_addr, lnk = AddLink(la, ANY_ADDR, dst_addr, alias_addr,
NO_SRC_PORT, NO_DEST_PORT, ip_id, NO_SRC_PORT, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID); LINK_FRAGMENT_ID);
} }
return (lnk); return (lnk);
} }
/* Doesn't add a link if one is not found. */ /* Doesn't add a link if one is not found. */
struct alias_link * struct alias_link *
FindFragmentIn2(struct libalias *la, struct in_addr dst_addr, FindFragmentIn2(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, u_short ip_id) struct in_addr alias_addr, u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return FindLinkIn(la, dst_addr, alias_addr, return FindLinkIn(la, dst_addr, alias_addr,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID, 0); LINK_FRAGMENT_ID, 0);
} }
struct alias_link * struct alias_link *
AddFragmentPtrLink(struct libalias *la, struct in_addr dst_addr, AddFragmentPtrLink(struct libalias *la, struct in_addr dst_addr,
u_short ip_id) u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return AddLink(la, NO_ADDR, dst_addr, NO_ADDR, return AddLink(la, ANY_ADDR, dst_addr, ANY_ADDR,
NO_SRC_PORT, NO_DEST_PORT, ip_id, NO_SRC_PORT, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_PTR); LINK_FRAGMENT_PTR);
} }
struct alias_link * struct alias_link *
FindFragmentPtr(struct libalias *la, struct in_addr dst_addr, FindFragmentPtr(struct libalias *la, struct in_addr dst_addr,
u_short ip_id) u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return FindLinkIn(la, dst_addr, NO_ADDR, return FindLinkIn(la, dst_addr, ANY_ADDR,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_PTR, 0); LINK_FRAGMENT_PTR, 0);
} }
struct alias_link * struct alias_link *
FindProtoIn(struct libalias *la, struct in_addr dst_addr, FindProtoIn(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_char proto) u_char proto)
▲ Show 20 Lines • Show All 131 Lines • ▼ Show 20 LinesAddPptp(struct libalias *la, struct in_addr src_addr,
return (lnk); return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpOutByCallId(struct libalias *la, struct in_addr src_addr, FindPptpOutByCallId(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_int16_t src_call_id) u_int16_t src_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, 0, 0, LINK_PPTP); LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) if (lnk->src_addr.s_addr == src_addr.s_addr &&
if (lnk->link_type == LINK_PPTP &&
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->src_port == src_call_id) lnk->src_port == src_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpOutByPeerCallId(struct libalias *la, struct in_addr src_addr, FindPptpOutByPeerCallId(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_int16_t dst_call_id) u_int16_t dst_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, 0, 0, LINK_PPTP); LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) if (lnk->src_addr.s_addr == src_addr.s_addr &&
if (lnk->link_type == LINK_PPTP &&
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->dst_port == dst_call_id) lnk->dst_port == dst_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpInByCallId(struct libalias *la, struct in_addr dst_addr, FindPptpInByCallId(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_int16_t dst_call_id) u_int16_t dst_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointIn(alias_addr, 0, LINK_PPTP);
LIST_FOREACH(lnk, &la->linkTableIn[i], list_in) LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
if (lnk->link_type == LINK_PPTP && if (lnk->dst_port == dst_call_id &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->alias_addr.s_addr == alias_addr.s_addr && lnk->alias_addr.s_addr == alias_addr.s_addr)
lnk->dst_port == dst_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpInByPeerCallId(struct libalias *la, struct in_addr dst_addr, FindPptpInByPeerCallId(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_int16_t alias_call_id) u_int16_t alias_call_id)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, dst_addr, alias_addr, LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
0 /* any */ , alias_call_id, if (lnk->alias_port == alias_call_id &&
LINK_PPTP, 0); lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->alias_addr.s_addr == alias_addr.s_addr)
break;
return (lnk); return (lnk);
} }
struct alias_link * struct alias_link *
FindRtspOut(struct libalias *la, struct in_addr src_addr, FindRtspOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
Show All 30 Lines
} }
struct in_addr struct in_addr
FindOriginalAddress(struct libalias *la, struct in_addr alias_addr) FindOriginalAddress(struct libalias *la, struct in_addr alias_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, NO_ADDR, alias_addr, lnk = FindLinkIn(la, ANY_ADDR, alias_addr,
0, 0, LINK_ADDR, 0); 0, 0, LINK_ADDR, 0);
if (lnk == NULL) { if (lnk == NULL) {
la->newDefaultLink = 1; la->newDefaultLink = 1;
if (la->targetAddress.s_addr == INADDR_ANY) if (la->targetAddress.s_addr == INADDR_ANY)
return (alias_addr); return (alias_addr);
else if (la->targetAddress.s_addr == INADDR_NONE) else if (la->targetAddress.s_addr == INADDR_NONE)
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : alias_addr; la->aliasAddress : alias_addr;
Show All 15 Lines
} }
struct in_addr struct in_addr
FindAliasAddress(struct libalias *la, struct in_addr original_addr) FindAliasAddress(struct libalias *la, struct in_addr original_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkOut(la, original_addr, NO_ADDR, lnk = FindLinkOut(la, original_addr, ANY_ADDR,
0, 0, LINK_ADDR, 0); 0, 0, LINK_ADDR, 0);
if (lnk == NULL) { if (lnk == NULL) {
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : original_addr; la->aliasAddress : original_addr;
} else { } else {
if (lnk->alias_addr.s_addr == INADDR_ANY) if (lnk->alias_addr.s_addr == INADDR_ANY)
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : original_addr; la->aliasAddress : original_addr;
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
void void
SetStateIn(struct alias_link *lnk, int state) SetStateIn(struct alias_link *lnk, int state)
{ {
/* TCP input state */ /* TCP input state */
switch (state) { switch (state) {
case ALIAS_TCP_STATE_DISCONNECTED: case ALIAS_TCP_STATE_DISCONNECTED:
if (lnk->data.tcp->state.out != ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.out != ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_DEAD; lnk->expire.timeout = TCP_EXPIRE_DEAD;
else else
lnk->expire_time = TCP_EXPIRE_SINGLEDEAD; lnk->expire.timeout = TCP_EXPIRE_SINGLEDEAD;
break; break;
case ALIAS_TCP_STATE_CONNECTED: case ALIAS_TCP_STATE_CONNECTED:
if (lnk->data.tcp->state.out == ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.out == ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_CONNECTED; lnk->expire.timeout = TCP_EXPIRE_CONNECTED;
break; break;
default: default:
#ifdef _KERNEL #ifdef _KERNEL
panic("libalias:SetStateIn() unknown state"); panic("libalias:SetStateIn() unknown state");
#else #else
abort(); abort();
#endif #endif
} }
lnk->data.tcp->state.in = state; lnk->data.tcp->state.in = state;
} }
void void
SetStateOut(struct alias_link *lnk, int state) SetStateOut(struct alias_link *lnk, int state)
{ {
/* TCP output state */ /* TCP output state */
switch (state) { switch (state) {
case ALIAS_TCP_STATE_DISCONNECTED: case ALIAS_TCP_STATE_DISCONNECTED:
if (lnk->data.tcp->state.in != ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.in != ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_DEAD; lnk->expire.timeout = TCP_EXPIRE_DEAD;
else else
lnk->expire_time = TCP_EXPIRE_SINGLEDEAD; lnk->expire.timeout = TCP_EXPIRE_SINGLEDEAD;
break; break;
case ALIAS_TCP_STATE_CONNECTED: case ALIAS_TCP_STATE_CONNECTED:
if (lnk->data.tcp->state.in == ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.in == ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_CONNECTED; lnk->expire.timeout = TCP_EXPIRE_CONNECTED;
break; break;
default: default:
#ifdef _KERNEL #ifdef _KERNEL
panic("libalias:SetStateOut() unknown state"); panic("libalias:SetStateOut() unknown state");
#else #else
abort(); abort();
#endif #endif
} }
▲ Show 20 Lines • Show All 232 Lines • ▼ Show 20 Lines
SetExpire(struct alias_link *lnk, int expire) SetExpire(struct alias_link *lnk, int expire)
{ {
if (expire == 0) { if (expire == 0) {
lnk->flags &= ~LINK_PERMANENT; lnk->flags &= ~LINK_PERMANENT;
DeleteLink(&lnk); DeleteLink(&lnk);
} else if (expire == -1) { } else if (expire == -1) {
lnk->flags |= LINK_PERMANENT; lnk->flags |= LINK_PERMANENT;
} else if (expire > 0) { } else if (expire > 0) {
lnk->expire_time = expire; lnk->expire.timeout = expire;
} else { } else {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/SetExpire(): "); fprintf(stderr, "PacketAlias/SetExpire(): ");
fprintf(stderr, "error in expire parameter\n"); fprintf(stderr, "error in expire parameter\n");
#endif #endif
} }
} }
▲ Show 20 Lines • Show All 187 Lines • ▼ Show 20 Lines
LibAliasAddServer(struct libalias *la, struct alias_link *lnk, struct in_addr addr, u_short port) LibAliasAddServer(struct libalias *la, struct alias_link *lnk, struct in_addr addr, u_short port)
{ {
struct server *server; struct server *server;
int res; int res;
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
(void)la; (void)la;
switch (lnk->link_type) {
case LINK_PPTP:
server = NULL;
break;
default:
server = malloc(sizeof(struct server)); server = malloc(sizeof(struct server));
break;
}
if (server != NULL) { if (server != NULL) {
struct server *head; struct server *head;
server->addr = addr; server->addr = addr;
server->port = port; server->port = port;
head = lnk->server; head = lnk->server;
if (head == NULL) if (head == NULL) {
server->next = server; server->next = server;
else { /* not usable for outgoing connections */
LIST_REMOVE(lnk, all.out);
} else {
struct server *s; struct server *s;
for (s = head; s->next != head; s = s->next) for (s = head; s->next != head; s = s->next)
; ;
s->next = server; s->next = server;
server->next = head; server->next = head;
} }
lnk->server = server; lnk->server = server;
Show All 37 Lines
/* Static address translation */ /* Static address translation */
struct alias_link * struct alias_link *
LibAliasRedirectAddr(struct libalias *la, struct in_addr src_addr, LibAliasRedirectAddr(struct libalias *la, struct in_addr src_addr,
struct in_addr alias_addr) struct in_addr alias_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
lnk = AddLink(la, src_addr, NO_ADDR, alias_addr, lnk = AddLink(la, src_addr, ANY_ADDR, alias_addr,
0, 0, 0, 0, 0, 0,
LINK_ADDR); LINK_ADDR);
if (lnk != NULL) { if (lnk != NULL) {
lnk->flags |= LINK_PERMANENT; lnk->flags |= LINK_PERMANENT;
} }
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
else { else {
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines#ifdef _KERNEL
LibAliasTime = time_uptime; LibAliasTime = time_uptime;
#else #else
LibAliasTime = time(NULL); LibAliasTime = time(NULL);
#endif #endif
for (i = 0; i < LINK_TABLE_OUT_SIZE; i++) for (i = 0; i < LINK_TABLE_OUT_SIZE; i++)
LIST_INIT(&la->linkTableOut[i]); LIST_INIT(&la->linkTableOut[i]);
for (i = 0; i < LINK_TABLE_IN_SIZE; i++) for (i = 0; i < LINK_TABLE_IN_SIZE; i++)
LIST_INIT(&la->linkTableIn[i]); LIST_INIT(&la->groupTableIn[i]);
LIST_INIT(&la->pptpTable);
TAILQ_INIT(&la->checkExpire); TAILQ_INIT(&la->checkExpire);
#ifdef _KERNEL #ifdef _KERNEL
AliasSctpInit(la); AliasSctpInit(la);
#endif #endif
LIBALIAS_LOCK_INIT(la); LIBALIAS_LOCK_INIT(la);
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
} else { } else {
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
la->deleteAllLinks = 1; la->deleteAllLinks = 1;
CleanupAliasData(la); CleanupAliasData(la);
la->deleteAllLinks = 0; la->deleteAllLinks = 0;
#ifdef _KERNEL #ifdef _KERNEL
AliasSctpTerm(la); AliasSctpTerm(la);
AliasSctpInit(la); AliasSctpInit(la);
#endif #endif
} }
la->aliasAddress.s_addr = INADDR_ANY; la->aliasAddress.s_addr = INADDR_ANY;
la->targetAddress.s_addr = INADDR_ANY; la->targetAddress.s_addr = INADDR_ANY;
la->aliasPortLower = 0x8000;
la->aliasPortLength = 0x8000;
la->icmpLinkCount = 0; la->icmpLinkCount = 0;
la->udpLinkCount = 0; la->udpLinkCount = 0;
la->tcpLinkCount = 0; la->tcpLinkCount = 0;
la->sctpLinkCount = 0; la->sctpLinkCount = 0;
la->pptpLinkCount = 0; la->pptpLinkCount = 0;
la->protoLinkCount = 0; la->protoLinkCount = 0;
la->fragmentIdLinkCount = 0; la->fragmentIdLinkCount = 0;
▲ Show 20 Lines • Show All 380 Lines • Show Last 20 Lines
View Options

multimedia/libxine/files/patch-ffmpeg4

Show First 20 Lines • Show All 214 Lines • ▼ Show 20 Lines
/* Dummy port number codes used for FindLinkIn/Out() and AddLink(). /* Dummy port number codes used for FindLinkIn/Out() and AddLink().
These constants can be anything except zero, which indicates an These constants can be anything except zero, which indicates an
unknown port number. */ unknown port number. */
#define NO_DEST_PORT 1 #define NO_DEST_PORT 1
#define NO_SRC_PORT 1 #define NO_SRC_PORT 1
/* Dummy address used for FindLinkIn/Out() and AddLink(). /* Matches any/unknown address in FindLinkIn/Out() and AddLink(). */
The value of this variable is never used. */ static struct in_addr const ANY_ADDR = { INADDR_ANY };
static struct in_addr const NO_ADDR;
/* Data Structures /* Data Structures
The fundamental data structure used in this program is The fundamental data structure used in this program is
"struct alias_link". Whenever a TCP connection is made, "struct alias_link". Whenever a TCP connection is made,
a UDP datagram is sent out, or an ICMP echo request is made, a UDP datagram is sent out, or an ICMP echo request is made,
a link record is made (if it has not already been created). a link record is made (if it has not already been created).
The link record is identified by the source address/port The link record is identified by the source address/port
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
/* flag bits */ /* flag bits */
#define LINK_UNKNOWN_DEST_PORT 0x01 #define LINK_UNKNOWN_DEST_PORT 0x01
#define LINK_UNKNOWN_DEST_ADDR 0x02 #define LINK_UNKNOWN_DEST_ADDR 0x02
#define LINK_PERMANENT 0x04 #define LINK_PERMANENT 0x04
#define LINK_PARTIALLY_SPECIFIED 0x03 /* logical-or of first two bits */ #define LINK_PARTIALLY_SPECIFIED 0x03 /* logical-or of first two bits */
#define LINK_UNFIREWALLED 0x08 #define LINK_UNFIREWALLED 0x08
int timestamp; /* Time link was last accessed */ int timestamp; /* Time link was last accessed */
int expire_time; /* Expire time for link */
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
int sockfd; /* socket descriptor */ int sockfd; /* socket descriptor */
#endif #endif
/* Linked list of pointers for input and output lookup tables */ /* Linked list of pointers for input and output lookup tables */
LIST_ENTRY (alias_link) list_out; union {
LIST_ENTRY (alias_link) list_in; struct {
TAILQ_ENTRY (alias_link) list_expire; LIST_ENTRY(alias_link) in;
LIST_ENTRY(alias_link) out;
} all;
struct {
LIST_ENTRY(alias_link) list;
} pptp;
};
struct {
TAILQ_ENTRY(alias_link) list;
int timeout; /* Expire time for link */
} expire;
/* Auxiliary data */ /* Auxiliary data */
union { union {
char *frag_ptr; char *frag_ptr;
struct in_addr frag_addr; struct in_addr frag_addr;
struct tcp_dat *tcp; struct tcp_dat *tcp;
} data; } data;
}; };
Show All 36 Lines StartPointOut() -- link table initial search point for
outgoing packets outgoing packets
Miscellaneous: Miscellaneous:
SeqDiff() -- difference between two TCP sequences SeqDiff() -- difference between two TCP sequences
ShowAliasStats() -- send alias statistics to a monitor file ShowAliasStats() -- send alias statistics to a monitor file
*/ */
/* Local prototypes */ /* Local prototypes */
static u_int StartPointIn(struct in_addr, u_short, int); static struct group_in *
StartPointIn(struct libalias *, struct in_addr, u_short, int, int);
static u_int static u_int
StartPointOut(struct in_addr, struct in_addr, StartPointOut(struct in_addr, struct in_addr, u_short, u_short, int);
u_short, u_short, int);
static int SeqDiff(u_long, u_long); static int SeqDiff(u_long, u_long);
#ifndef NO_FW_PUNCH #ifndef NO_FW_PUNCH
/* Firewall control */ /* Firewall control */
static void InitPunchFW(struct libalias *); static void InitPunchFW(struct libalias *);
static void UninitPunchFW(struct libalias *); static void UninitPunchFW(struct libalias *);
static void ClearFWHole(struct alias_link *); static void ClearFWHole(struct alias_link *);
#endif #endif
/* Log file control */ /* Log file control */
static void ShowAliasStats(struct libalias *); static void ShowAliasStats(struct libalias *);
static int InitPacketAliasLog(struct libalias *); static int InitPacketAliasLog(struct libalias *);
static void UninitPacketAliasLog(struct libalias *); static void UninitPacketAliasLog(struct libalias *);
void SctpShowAliasStats(struct libalias *la); void SctpShowAliasStats(struct libalias *la);
static u_int #define INGUARD \
StartPointIn(struct in_addr alias_addr, if (grp->alias_port != alias_port || \
u_short alias_port, grp->link_type != link_type || \
int link_type) grp->alias_addr.s_addr != alias_addr.s_addr) \
continue;
static struct group_in *
StartPointIn(struct libalias *la,
struct in_addr alias_addr, u_short alias_port, int link_type,
int create)
{ {
u_int n; u_int n;
struct group_in *grp, *tmp;
n = alias_addr.s_addr; n = alias_addr.s_addr;
if (link_type != LINK_PPTP)
n += alias_port; n += alias_port;
n += link_type; n += link_type;
return (n % LINK_TABLE_IN_SIZE); n %= LINK_TABLE_IN_SIZE;
LIST_FOREACH_SAFE(grp, &la->groupTableIn[n], group_in, tmp) {
/* Auto cleanup */
if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {
LIST_REMOVE(grp, group_in);
free(grp);
} else {
INGUARD;
return (grp);
} }
}
if (!create || (grp = malloc(sizeof(*grp))) == NULL)
return (grp);
grp->alias_addr = alias_addr;
grp->alias_port = alias_port;
grp->link_type = link_type;
LIST_INIT(&grp->full);
LIST_INIT(&grp->partial);
LIST_INSERT_HEAD(&la->groupTableIn[n], grp, group_in);
return (grp);
}
#undef INGUARD
static u_int static u_int
StartPointOut(struct in_addr src_addr, struct in_addr dst_addr, StartPointOut(struct in_addr src_addr, struct in_addr dst_addr,
u_short src_port, u_short dst_port, int link_type) u_short src_port, u_short dst_port, int link_type)
{ {
u_int n; u_int n;
n = src_addr.s_addr; n = src_addr.s_addr;
n += dst_addr.s_addr; n += dst_addr.s_addr;
if (link_type != LINK_PPTP) {
n += src_port; n += src_port;
n += dst_port; n += dst_port;
}
n += link_type; n += link_type;
return (n % LINK_TABLE_OUT_SIZE); return (n % LINK_TABLE_OUT_SIZE);
} }
static int static int
SeqDiff(u_long x, u_long y) SeqDiff(u_long x, u_long y)
{ {
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
/* Local prototypes */ /* Local prototypes */
static int GetNewPort(struct libalias *, struct alias_link *, int); static int GetNewPort(struct libalias *, struct alias_link *, int);
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
static u_short GetSocket(struct libalias *, u_short, int *, int); static u_short GetSocket(struct libalias *, u_short, int *, int);
#endif #endif
static void CleanupAliasData(struct libalias *); static void CleanupAliasData(struct libalias *);
static void CleanupLink(struct libalias *, struct alias_link **); static void CleanupLink(struct libalias *, struct alias_link **);
static void DeleteLink(struct alias_link **); static void DeleteLink(struct alias_link **);
static struct alias_link *
UseLink(struct libalias *, struct alias_link *);
static struct alias_link * static struct alias_link *
ReLink(struct alias_link *, ReLink(struct alias_link *,
struct in_addr, struct in_addr, struct in_addr, struct in_addr, struct in_addr, struct in_addr,
u_short, u_short, int, int); u_short, u_short, int, int);
static struct alias_link * static struct alias_link *
FindLinkOut(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int); FindLinkOut(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int);
static struct alias_link * static struct alias_link *
FindLinkIn(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int); FindLinkIn(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int);
#define ALIAS_PORT_BASE 0x08000 static u_short _RandomPort(struct libalias *la);
#define ALIAS_PORT_MASK 0x07fff
#define ALIAS_PORT_MASK_EVEN 0x07ffe
#define GET_NEW_PORT_MAX_ATTEMPTS 20 #define GET_NEW_PORT_MAX_ATTEMPTS 20
#define FIND_EVEN_ALIAS_BASE 1 /* get random port in network byte order */
static u_short
_RandomPort(struct libalias *la) {
u_short port;
port = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
return ntohs(port);
}
/* GetNewPort() allocates port numbers. Note that if a port number /* GetNewPort() allocates port numbers. Note that if a port number
is already in use, that does not mean that it cannot be used by is already in use, that does not mean that it cannot be used by
another link concurrently. This is because GetNewPort() looks for another link concurrently. This is because GetNewPort() looks for
unused triplets: (dest addr, dest port, alias port). */ unused triplets: (dest addr, dest port, alias port). */
static int static int
GetNewPort(struct libalias *la, struct alias_link *lnk, int alias_port_param) GetNewPort(struct libalias *la, struct alias_link *lnk, int alias_port_param)
{ {
int i; int i;
int max_trials; int max_trials;
u_short port_sys; u_short port;
u_short port_net;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* /*
* Description of alias_port_param for GetNewPort(). When * Description of alias_port_param for GetNewPort(). When
* this parameter is zero or positive, it precisely specifies * this parameter is zero or positive, it precisely specifies
* the port number. GetNewPort() will return this number * the port number. GetNewPort() will return this number
* without check that it is in use. * without check that it is in use.
*
* The aliasing port is automatically selected by one of
* two methods below:
*
* When this parameter is GET_ALIAS_PORT, it indicates to get * When this parameter is GET_ALIAS_PORT, it indicates to get
* a randomly selected port number. * a randomly selected port number.
*/ */
if (alias_port_param == GET_ALIAS_PORT) { if (alias_port_param >= 0 && alias_port_param < 0x10000) {
/*
* The aliasing port is automatically selected by one of
* two methods below:
*/
max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) {
/*
* When the PKT_ALIAS_SAME_PORTS option is chosen,
* the first try will be the actual source port. If
* this is already in use, the remainder of the
* trials will be random.
*/
port_net = lnk->src_port;
port_sys = ntohs(port_net);
} else if (la->aliasPortLower) {
/* First trial is a random port in the aliasing range. */
port_sys = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
port_net = htons(port_sys);
} else {
/* First trial and all subsequent are random. */
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
port_net = htons(port_sys);
}
} else if (alias_port_param >= 0 && alias_port_param < 0x10000) {
lnk->alias_port = (u_short) alias_port_param; lnk->alias_port = (u_short) alias_port_param;
return (0); return (0);
} else { }
if (alias_port_param != GET_ALIAS_PORT) {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/GetNewPort(): "); fprintf(stderr, "PacketAlias/GetNewPort(): ");
fprintf(stderr, "input parameter error\n"); fprintf(stderr, "input parameter error\n");
#endif #endif
return (-1); return (-1);
} }
max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
/*
* When the PKT_ALIAS_SAME_PORTS option is chosen,
* the first try will be the actual source port. If
* this is already in use, the remainder of the
* trials will be random.
*/
port = (la->packetAliasMode & PKT_ALIAS_SAME_PORTS)
? lnk->src_port
: _RandomPort(la);
/* Port number search */ /* Port number search */
for (i = 0; i < max_trials; i++) { for (i = 0; i < max_trials; i++, port = _RandomPort(la)) {
int go_ahead; struct group_in *grp;
struct alias_link *search_result; struct alias_link *search_result;
search_result = FindLinkIn(la, lnk->dst_addr, lnk->alias_addr, grp = StartPointIn(la, lnk->alias_addr, port, lnk->link_type, 0);
lnk->dst_port, port_net, if (grp == NULL)
lnk->link_type, 0); break;
LIST_FOREACH(search_result, &grp->full, all.in) {
if (lnk->dst_addr.s_addr == search_result->dst_addr.s_addr &&
lnk->dst_port == search_result->dst_port)
break; /* found match */
}
if (search_result == NULL) if (search_result == NULL)
go_ahead = 1; break;
else if (!(lnk->flags & LINK_PARTIALLY_SPECIFIED)
&& (search_result->flags & LINK_PARTIALLY_SPECIFIED))
go_ahead = 1;
else
go_ahead = 0;
if (go_ahead) {
#ifndef NO_USE_SOCKETS
if ((la->packetAliasMode & PKT_ALIAS_USE_SOCKETS)
&& (lnk->flags & LINK_PARTIALLY_SPECIFIED)
&& ((lnk->link_type == LINK_TCP) ||
(lnk->link_type == LINK_UDP))) {
if (GetSocket(la, port_net, &lnk->sockfd, lnk->link_type)) {
lnk->alias_port = port_net;
return (0);
} }
} else {
#endif
lnk->alias_port = port_net;
return (0);
#ifndef NO_USE_SOCKETS
}
#endif
}
if (la->aliasPortLower) {
port_sys = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
port_net = htons(port_sys);
} else {
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
port_net = htons(port_sys);
}
}
if (i >= max_trials) {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/GetNewPort(): "); fprintf(stderr, "PacketAlias/GetNewPort(): ");
fprintf(stderr, "could not find free port\n"); fprintf(stderr, "could not find free port\n");
#endif #endif
return (-1);
}
#ifndef NO_USE_SOCKETS
if ((la->packetAliasMode & PKT_ALIAS_USE_SOCKETS) &&
(lnk->flags & LINK_PARTIALLY_SPECIFIED) &&
((lnk->link_type == LINK_TCP) ||
(lnk->link_type == LINK_UDP))) {
if (!GetSocket(la, port, &lnk->sockfd, lnk->link_type)) {
return (-1); return (-1);
} }
}
#endif
lnk->alias_port = port;
return (0);
}
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
static u_short static u_short
GetSocket(struct libalias *la, u_short port_net, int *sockfd, int link_type) GetSocket(struct libalias *la, u_short port_net, int *sockfd, int link_type)
{ {
int err; int err;
int sock; int sock;
struct sockaddr_in sock_addr; struct sockaddr_in sock_addr;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 LinesFindNewPortGroup(struct libalias *la,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
u_short port_count, u_short port_count,
u_char proto, u_char proto,
u_char align) u_char align)
{ {
int i, j; int i, j;
int max_trials; int max_trials;
u_short port_sys; u_short port;
int link_type; int link_type;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* /*
* Get link_type from protocol * Get link_type from protocol
*/ */
switch (proto) { switch (proto) {
Show All 15 LinesFindNewPortGroup(struct libalias *la,
max_trials = GET_NEW_PORT_MAX_ATTEMPTS; max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) { if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) {
/* /*
* When the ALIAS_SAME_PORTS option is chosen, the first * When the ALIAS_SAME_PORTS option is chosen, the first
* try will be the actual source port. If this is already * try will be the actual source port. If this is already
* in use, the remainder of the trials will be random. * in use, the remainder of the trials will be random.
*/ */
port_sys = ntohs(src_port); port = src_port;
} else { } else {
/* First trial and all subsequent are random. */ port = _RandomPort(la);
if (align == FIND_EVEN_ALIAS_BASE)
port_sys = arc4random() & ALIAS_PORT_MASK_EVEN;
else
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
} }
/* Port number search */ /* Port number search */
for (i = 0; i < max_trials; i++) { for (i = 0; i < max_trials; i++, port = _RandomPort(la)) {
struct alias_link *search_result; struct alias_link *search_result;
for (j = 0; j < port_count; j++) if (align)
port &= htons(0xfffe);
for (j = 0; j < port_count; j++) {
u_short port_j = ntohs(port) + j;
if ((search_result = FindLinkIn(la, dst_addr, if ((search_result = FindLinkIn(la, dst_addr,
alias_addr, dst_port, htons(port_sys + j), alias_addr, dst_port, htons(port_j),
link_type, 0)) != NULL) link_type, 0)) != NULL)
break; break;
}
/* Found a good range, return base */ /* Found a good range, return base */
if (j == port_count) if (j == port_count)
return (htons(port_sys)); return (port);
/* Find a new base to try */
if (align == FIND_EVEN_ALIAS_BASE)
port_sys = arc4random() & ALIAS_PORT_MASK_EVEN;
else
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
} }
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/FindNewPortGroup(): "); fprintf(stderr, "PacketAlias/FindNewPortGroup(): ");
fprintf(stderr, "could not find free port(s)\n"); fprintf(stderr, "could not find free port(s)\n");
#endif #endif
return (0); return (0);
} }
static void static void
CleanupAliasData(struct libalias *la) CleanupAliasData(struct libalias *la)
{ {
struct alias_link *lnk, *lnk_tmp; struct alias_link *lnk, *lnk_tmp;
u_int i;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* permanent entries may stay */ /* permanent entries may stay */
TAILQ_FOREACH_SAFE(lnk, &la->checkExpire, list_expire, lnk_tmp) TAILQ_FOREACH_SAFE(lnk, &la->checkExpire, expire.list, lnk_tmp)
DeleteLink(&lnk); DeleteLink(&lnk);
for (i = 0; i < LINK_TABLE_IN_SIZE; i++) {
struct group_in *grp, *grp_tmp;
LIST_FOREACH_SAFE(grp, &la->groupTableIn[i], group_in, grp_tmp)
if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {
LIST_REMOVE(grp, group_in);
free(grp);
} }
}
}
static void static void
CleanupLink(struct libalias *la, struct alias_link **lnk) CleanupLink(struct libalias *la, struct alias_link **lnk)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
if (lnk == NULL || *lnk == NULL) if (lnk == NULL || *lnk == NULL)
return; return;
if (LibAliasTime - (*lnk)->timestamp > (*lnk)->expire_time) { if (LibAliasTime - (*lnk)->timestamp > (*lnk)->expire.timeout) {
DeleteLink(lnk); DeleteLink(lnk);
if ((*lnk) == NULL) if ((*lnk) == NULL)
return; return;
} }
/* move to end, swap may fail on a single entry list */ /* move to end, swap may fail on a single entry list */
TAILQ_REMOVE(&la->checkExpire, (*lnk), list_expire); TAILQ_REMOVE(&la->checkExpire, (*lnk), expire.list);
TAILQ_INSERT_TAIL(&la->checkExpire, (*lnk), list_expire); TAILQ_INSERT_TAIL(&la->checkExpire, (*lnk), expire.list);
} }
static struct alias_link *
UseLink(struct libalias *la, struct alias_link *lnk)
{
CleanupLink(la, &lnk);
if (lnk != NULL)
lnk->timestamp = LibAliasTime;
return (lnk);
}
static void static void
DeleteLink(struct alias_link **plnk) DeleteLink(struct alias_link **plnk)
{ {
struct alias_link *lnk = *plnk; struct alias_link *lnk = *plnk;
struct libalias *la = lnk->la; struct libalias *la = lnk->la;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* Don't do anything if the link is marked permanent */ /* Don't do anything if the link is marked permanent */
if (la->deleteAllLinks == 0 && lnk->flags & LINK_PERMANENT) if (la->deleteAllLinks == 0 && lnk->flags & LINK_PERMANENT)
return; return;
#ifndef NO_FW_PUNCH #ifndef NO_FW_PUNCH
/* Delete associated firewall hole, if any */ /* Delete associated firewall hole, if any */
ClearFWHole(lnk); ClearFWHole(lnk);
#endif #endif
switch (lnk->link_type) {
case LINK_PPTP:
LIST_REMOVE(lnk, pptp.list);
break;
default:
/* Free memory allocated for LSNAT server pool */ /* Free memory allocated for LSNAT server pool */
if (lnk->server != NULL) { if (lnk->server != NULL) {
struct server *head, *curr, *next; struct server *head, *curr, *next;
head = curr = lnk->server; head = curr = lnk->server;
do { do {
next = curr->next; next = curr->next;
free(curr); free(curr);
} while ((curr = next) != head); } while ((curr = next) != head);
} } else {
/* Adjust output table pointers */ /* Adjust output table pointers */
LIST_REMOVE(lnk, list_out); LIST_REMOVE(lnk, all.out);
}
/* Adjust input table pointers */ /* Adjust input table pointers */
LIST_REMOVE(lnk, list_in); LIST_REMOVE(lnk, all.in);
break;
}
/* remove from housekeeping */ /* remove from housekeeping */
TAILQ_REMOVE(&la->checkExpire, lnk, list_expire); TAILQ_REMOVE(&la->checkExpire, lnk, expire.list);
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
/* Close socket, if one has been allocated */ /* Close socket, if one has been allocated */
if (lnk->sockfd != -1) { if (lnk->sockfd != -1) {
la->sockCount--; la->sockCount--;
close(lnk->sockfd); close(lnk->sockfd);
} }
#endif #endif
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
AddLink(struct libalias *la, struct in_addr src_addr, struct in_addr dst_addr, AddLink(struct libalias *la, struct in_addr src_addr, struct in_addr dst_addr,
struct in_addr alias_addr, u_short src_port, u_short dst_port, struct in_addr alias_addr, u_short src_port, u_short dst_port,
int alias_port_param, int link_type) int alias_port_param, int link_type)
{ {
u_int start_point; u_int start_point;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = malloc(sizeof(struct alias_link)); lnk = malloc(sizeof(struct alias_link));
if (lnk != NULL) { if (lnk == NULL) {
#ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink(): ");
fprintf(stderr, "malloc() call failed.\n");
#endif
return (NULL);
}
/* Basic initialization */ /* Basic initialization */
lnk->la = la; lnk->la = la;
lnk->src_addr = src_addr; lnk->src_addr = src_addr;
lnk->dst_addr = dst_addr; lnk->dst_addr = dst_addr;
lnk->alias_addr = alias_addr; lnk->alias_addr = alias_addr;
lnk->proxy_addr.s_addr = INADDR_ANY; lnk->proxy_addr.s_addr = INADDR_ANY;
lnk->src_port = src_port; lnk->src_port = src_port;
lnk->dst_port = dst_port; lnk->dst_port = dst_port;
lnk->proxy_port = 0; lnk->proxy_port = 0;
lnk->server = NULL; lnk->server = NULL;
lnk->link_type = link_type; lnk->link_type = link_type;
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
lnk->sockfd = -1; lnk->sockfd = -1;
#endif #endif
lnk->flags = 0; lnk->flags = 0;
lnk->pflags = 0; lnk->pflags = 0;
lnk->timestamp = LibAliasTime; lnk->timestamp = LibAliasTime;
/* Expiration time */ /* Expiration time */
switch (link_type) { switch (link_type) {
case LINK_ICMP: case LINK_ICMP:
lnk->expire_time = ICMP_EXPIRE_TIME; lnk->expire.timeout = ICMP_EXPIRE_TIME;
break; break;
case LINK_UDP: case LINK_UDP:
lnk->expire_time = UDP_EXPIRE_TIME; lnk->expire.timeout = UDP_EXPIRE_TIME;
break; break;
case LINK_TCP: case LINK_TCP:
lnk->expire_time = TCP_EXPIRE_INITIAL; lnk->expire.timeout = TCP_EXPIRE_INITIAL;
break; break;
case LINK_PPTP:
lnk->flags |= LINK_PERMANENT; /* no timeout. */
break;
case LINK_FRAGMENT_ID: case LINK_FRAGMENT_ID:
lnk->expire_time = FRAGMENT_ID_EXPIRE_TIME; lnk->expire.timeout = FRAGMENT_ID_EXPIRE_TIME;
break; break;
case LINK_FRAGMENT_PTR: case LINK_FRAGMENT_PTR:
lnk->expire_time = FRAGMENT_PTR_EXPIRE_TIME; lnk->expire.timeout = FRAGMENT_PTR_EXPIRE_TIME;
break; break;
case LINK_ADDR: case LINK_ADDR:
break; break;
default: default:
lnk->expire_time = PROTO_EXPIRE_TIME; lnk->expire.timeout = PROTO_EXPIRE_TIME;
break; break;
} }
/* Determine alias flags */ /* Determine alias flags */
if (dst_addr.s_addr == INADDR_ANY) if (dst_addr.s_addr == INADDR_ANY)
lnk->flags |= LINK_UNKNOWN_DEST_ADDR; lnk->flags |= LINK_UNKNOWN_DEST_ADDR;
if (dst_port == 0) if (dst_port == 0)
lnk->flags |= LINK_UNKNOWN_DEST_PORT; lnk->flags |= LINK_UNKNOWN_DEST_PORT;
/* Determine alias port */ /* Determine alias port */
if (GetNewPort(la, lnk, alias_port_param) != 0) { if (GetNewPort(la, lnk, alias_port_param) != 0) {
free(lnk); free(lnk);
return (NULL); return (NULL);
} }
/* Link-type dependent initialization */ /* Link-type dependent initialization */
switch (link_type) { switch (link_type) {
struct tcp_dat *aux_tcp;
case LINK_ICMP: case LINK_ICMP:
la->icmpLinkCount++; la->icmpLinkCount++;
break; break;
case LINK_UDP: case LINK_UDP:
la->udpLinkCount++; la->udpLinkCount++;
break; break;
case LINK_TCP: case LINK_TCP: {
struct tcp_dat *aux_tcp;
int i;
aux_tcp = malloc(sizeof(struct tcp_dat)); aux_tcp = malloc(sizeof(struct tcp_dat));
if (aux_tcp != NULL) { if (aux_tcp != NULL) {
int i; #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink: ");
fprintf(stderr, " cannot allocate auxiliary TCP data\n");
#endif
free(lnk);
return (NULL);
}
la->tcpLinkCount++; la->tcpLinkCount++;
aux_tcp->state.in = ALIAS_TCP_STATE_NOT_CONNECTED; aux_tcp->state.in = ALIAS_TCP_STATE_NOT_CONNECTED;
aux_tcp->state.out = ALIAS_TCP_STATE_NOT_CONNECTED; aux_tcp->state.out = ALIAS_TCP_STATE_NOT_CONNECTED;
aux_tcp->state.index = 0; aux_tcp->state.index = 0;
aux_tcp->state.ack_modified = 0; aux_tcp->state.ack_modified = 0;
for (i = 0; i < N_LINK_TCP_DATA; i++) for (i = 0; i < N_LINK_TCP_DATA; i++)
aux_tcp->ack[i].active = 0; aux_tcp->ack[i].active = 0;
aux_tcp->fwhole = -1; aux_tcp->fwhole = -1;
lnk->data.tcp = aux_tcp; lnk->data.tcp = aux_tcp;
} else {
#ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink: ");
fprintf(stderr, " cannot allocate auxiliary TCP data\n");
#endif
free(lnk);
return (NULL);
} }
break; break;
case LINK_PPTP: case LINK_PPTP:
la->pptpLinkCount++; la->pptpLinkCount++;
break; break;
case LINK_FRAGMENT_ID: case LINK_FRAGMENT_ID:
la->fragmentIdLinkCount++; la->fragmentIdLinkCount++;
break; break;
case LINK_FRAGMENT_PTR: case LINK_FRAGMENT_PTR:
la->fragmentPtrLinkCount++; la->fragmentPtrLinkCount++;
break; break;
case LINK_ADDR: case LINK_ADDR:
break; break;
default: default:
la->protoLinkCount++; la->protoLinkCount++;
break; break;
} }
switch (link_type) {
case LINK_PPTP:
LIST_INSERT_HEAD(&la->pptpTable, lnk, pptp.list);
break;
default: {
struct group_in *grp;
grp = StartPointIn(la, alias_addr, lnk->alias_port, link_type, 1);
if (grp == NULL) {
free(lnk);
return (NULL);
}
/* Set up pointers for output lookup table */ /* Set up pointers for output lookup table */
start_point = StartPointOut(src_addr, dst_addr, start_point = StartPointOut(src_addr, dst_addr,
src_port, dst_port, link_type); src_port, dst_port, link_type);
LIST_INSERT_HEAD(&la->linkTableOut[start_point], lnk, list_out); LIST_INSERT_HEAD(&la->linkTableOut[start_point], lnk, all.out);
/* Set up pointers for input lookup table */ /* Set up pointers for input lookup table */
start_point = StartPointIn(alias_addr, lnk->alias_port, link_type); if (lnk->flags & LINK_PARTIALLY_SPECIFIED)
LIST_INSERT_HEAD(&la->linkTableIn[start_point], lnk, list_in); LIST_INSERT_HEAD(&grp->partial, lnk, all.in);
else
LIST_INSERT_HEAD(&grp->full, lnk, all.in);
}
break;
}
/* Include the element into the housekeeping list */ /* Include the element into the housekeeping list */
TAILQ_INSERT_TAIL(&la->checkExpire, lnk, list_expire); TAILQ_INSERT_TAIL(&la->checkExpire, lnk, expire.list);
} else {
#ifdef LIBALIAS_DEBUG if (la->packetAliasMode & PKT_ALIAS_LOG)
fprintf(stderr, "PacketAlias/AddLink(): ");
fprintf(stderr, "malloc() call failed.\n");
#endif
}
if (la->packetAliasMode & PKT_ALIAS_LOG) {
ShowAliasStats(la); ShowAliasStats(la);
}
return (lnk); return (lnk);
} }
/* /*
* If alias_port_param is less than zero, alias port will be automatically * If alias_port_param is less than zero, alias port will be automatically
* chosen. If greater than zero, equal to alias port * chosen. If greater than zero, equal to alias port
*/ */
static struct alias_link * static struct alias_link *
Show All 19 Lines if (new_lnk != NULL &&
old_lnk->data.tcp->fwhole > 0) { old_lnk->data.tcp->fwhole > 0) {
PunchFWHole(new_lnk); PunchFWHole(new_lnk);
} }
#endif #endif
DeleteLink(&old_lnk); DeleteLink(&old_lnk);
return (new_lnk); return (new_lnk);
} }
#define OUTGUARD \
if (lnk->src_port != src_port || \
lnk->src_addr.s_addr != src_addr.s_addr || \
lnk->dst_addr.s_addr != dst_addr.s_addr || \
lnk->dst_port != dst_port || \
lnk->link_type != link_type) \
continue;
static struct alias_link * static struct alias_link *
_SearchLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr,
u_short src_port,
u_short dst_port,
int link_type) {
u_int i;
struct alias_link *lnk;
i = StartPointOut(src_addr, dst_addr, src_port, dst_port, link_type);
LIST_FOREACH(lnk, &la->linkTableOut[i], all.out) {
OUTGUARD;
return (UseLink(la, lnk));
}
return (NULL);
}
#undef OUTGUARD
static struct alias_link *
_FindLinkOut(struct libalias *la, struct in_addr src_addr, _FindLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
int link_type, int link_type,
int replace_partial_links) int replace_partial_links)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, src_port, dst_port, link_type); lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, dst_port, link_type);
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) { if (lnk != NULL || !replace_partial_links)
if (lnk->dst_addr.s_addr == dst_addr.s_addr && return (lnk);
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->src_port == src_port &&
lnk->dst_port == dst_port &&
lnk->link_type == link_type &&
lnk->server == NULL)
break;
}
CleanupLink(la, &lnk);
if (lnk != NULL)
lnk->timestamp = LibAliasTime;
/* Search for partially specified links. */ /* Search for partially specified links. */
if (lnk == NULL && replace_partial_links) {
if (dst_port != 0 && dst_addr.s_addr != INADDR_ANY) { if (dst_port != 0 && dst_addr.s_addr != INADDR_ANY) {
lnk = _FindLinkOut(la, src_addr, dst_addr, src_port, 0, lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, 0,
link_type, 0); link_type);
if (lnk == NULL) if (lnk == NULL)
lnk = _FindLinkOut(la, src_addr, NO_ADDR, src_port, lnk = _SearchLinkOut(la, src_addr, ANY_ADDR, src_port,
dst_port, link_type, 0); dst_port, link_type);
} }
if (lnk == NULL && if (lnk == NULL &&
(dst_port != 0 || dst_addr.s_addr != INADDR_ANY)) { (dst_port != 0 || dst_addr.s_addr != INADDR_ANY)) {
lnk = _FindLinkOut(la, src_addr, NO_ADDR, src_port, 0, lnk = _SearchLinkOut(la, src_addr, ANY_ADDR, src_port, 0,
link_type, 0); link_type);
} }
if (lnk != NULL) { if (lnk != NULL) {
lnk = ReLink(lnk, lnk = ReLink(lnk,
src_addr, dst_addr, lnk->alias_addr, src_addr, dst_addr, lnk->alias_addr,
src_port, dst_port, lnk->alias_port, src_port, dst_port, lnk->alias_port,
link_type); link_type);
} }
}
return (lnk); return (lnk);
} }
static struct alias_link * static struct alias_link *
FindLinkOut(struct libalias *la, struct in_addr src_addr, FindLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
Show All 10 Lines if (lnk == NULL) {
/* /*
* The following allows permanent links to be specified as * The following allows permanent links to be specified as
* using the default source address (i.e. device interface * using the default source address (i.e. device interface
* address) without knowing in advance what that address * address) without knowing in advance what that address
* is. * is.
*/ */
if (la->aliasAddress.s_addr != INADDR_ANY && if (la->aliasAddress.s_addr != INADDR_ANY &&
src_addr.s_addr == la->aliasAddress.s_addr) { src_addr.s_addr == la->aliasAddress.s_addr) {
lnk = _FindLinkOut(la, NO_ADDR, dst_addr, src_port, dst_port, lnk = _FindLinkOut(la, ANY_ADDR, dst_addr, src_port, dst_port,
link_type, replace_partial_links); link_type, replace_partial_links);
} }
} }
return (lnk); return (lnk);
} }
static struct alias_link * static struct alias_link *
_FindLinkIn(struct libalias *la, struct in_addr dst_addr, _FindLinkIn(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_short dst_port, u_short dst_port,
u_short alias_port, u_short alias_port,
int link_type, int link_type,
int replace_partial_links) int replace_partial_links)
{ {
int flags_in; int flags_in;
u_int start_point; struct group_in *grp;
struct alias_link *lnk; struct alias_link *lnk;
struct alias_link *lnk_fully_specified;
struct alias_link *lnk_unknown_all; struct alias_link *lnk_unknown_all;
struct alias_link *lnk_unknown_dst_addr; struct alias_link *lnk_unknown_dst_addr;
struct alias_link *lnk_unknown_dst_port; struct alias_link *lnk_unknown_dst_port;
struct in_addr src_addr;
u_short src_port;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* Initialize pointers */ /* Initialize pointers */
lnk_fully_specified = NULL;
lnk_unknown_all = NULL; lnk_unknown_all = NULL;
lnk_unknown_dst_addr = NULL; lnk_unknown_dst_addr = NULL;
lnk_unknown_dst_port = NULL; lnk_unknown_dst_port = NULL;
/* If either the dest addr or port is unknown, the search /* If either the dest addr or port is unknown, the search
* loop will have to know about this. */ * loop will have to know about this. */
flags_in = 0; flags_in = 0;
if (dst_addr.s_addr == INADDR_ANY) if (dst_addr.s_addr == INADDR_ANY)
flags_in |= LINK_UNKNOWN_DEST_ADDR; flags_in |= LINK_UNKNOWN_DEST_ADDR;
if (dst_port == 0) if (dst_port == 0)
flags_in |= LINK_UNKNOWN_DEST_PORT; flags_in |= LINK_UNKNOWN_DEST_PORT;
/* Search loop */ /* Search loop */
start_point = StartPointIn(alias_addr, alias_port, link_type); grp = StartPointIn(la, alias_addr, alias_port, link_type, 0);
LIST_FOREACH(lnk, &la->linkTableIn[start_point], list_in) { if (grp == NULL)
int flags; return (NULL);
flags = flags_in | lnk->flags; switch (flags_in) {
if (!(flags & LINK_PARTIALLY_SPECIFIED)) { case 0:
if (lnk->alias_addr.s_addr == alias_addr.s_addr LIST_FOREACH(lnk, &grp->full, all.in) {
&& lnk->alias_port == alias_port if (lnk->dst_addr.s_addr == dst_addr.s_addr &&
&& lnk->dst_addr.s_addr == dst_addr.s_addr lnk->dst_port == dst_port)
&& lnk->dst_port == dst_port return (UseLink(la, lnk));
&& lnk->link_type == link_type) { }
lnk_fully_specified = lnk;
break; break;
case LINK_UNKNOWN_DEST_PORT:
LIST_FOREACH(lnk, &grp->full, all.in) {
if(lnk->dst_addr.s_addr == dst_addr.s_addr) {
lnk_unknown_dst_port = lnk;
break;
} }
} else if ((flags & LINK_UNKNOWN_DEST_ADDR)
&& (flags & LINK_UNKNOWN_DEST_PORT)) {
if (lnk->alias_addr.s_addr == alias_addr.s_addr
&& lnk->alias_port == alias_port
&& lnk->link_type == link_type) {
if (lnk_unknown_all == NULL)
lnk_unknown_all = lnk;
} }
} else if (flags & LINK_UNKNOWN_DEST_ADDR) { break;
if (lnk->alias_addr.s_addr == alias_addr.s_addr case LINK_UNKNOWN_DEST_ADDR:
&& lnk->alias_port == alias_port LIST_FOREACH(lnk, &grp->full, all.in) {
&& lnk->link_type == link_type if(lnk->dst_port == dst_port) {
&& lnk->dst_port == dst_port) {
if (lnk_unknown_dst_addr == NULL)
lnk_unknown_dst_addr = lnk; lnk_unknown_dst_addr = lnk;
break;
} }
} else if (flags & LINK_UNKNOWN_DEST_PORT) { }
if (lnk->alias_addr.s_addr == alias_addr.s_addr break;
&& lnk->alias_port == alias_port case LINK_PARTIALLY_SPECIFIED:
&& lnk->link_type == link_type lnk_unknown_all = LIST_FIRST(&grp->full);
&& lnk->dst_addr.s_addr == dst_addr.s_addr) { break;
if (lnk_unknown_dst_port == NULL) }
if (lnk_unknown_dst_port == NULL) {
LIST_FOREACH(lnk, &grp->partial, all.in) {
int flags = (flags_in | lnk->flags) & LINK_PARTIALLY_SPECIFIED;
if (flags == LINK_PARTIALLY_SPECIFIED &&
lnk_unknown_all == NULL)
lnk_unknown_all = lnk;
if (flags == LINK_UNKNOWN_DEST_ADDR &&
lnk->dst_port == dst_port &&
lnk_unknown_dst_addr == NULL)
lnk_unknown_dst_addr = lnk;
if (flags == LINK_UNKNOWN_DEST_PORT &&
lnk->dst_addr.s_addr == dst_addr.s_addr) {
lnk_unknown_dst_port = lnk; lnk_unknown_dst_port = lnk;
break;
} }
} }
} }
CleanupLink(la, &lnk_fully_specified); lnk = (lnk_unknown_dst_port != NULL) ? lnk_unknown_dst_port
if (lnk_fully_specified != NULL) { : (lnk_unknown_dst_addr != NULL) ? lnk_unknown_dst_addr
lnk_fully_specified->timestamp = LibAliasTime; : lnk_unknown_all;
lnk = lnk_fully_specified;
} else if (lnk_unknown_dst_port != NULL)
lnk = lnk_unknown_dst_port;
else if (lnk_unknown_dst_addr != NULL)
lnk = lnk_unknown_dst_addr;
else if (lnk_unknown_all != NULL)
lnk = lnk_unknown_all;
else
return (NULL);
if (replace_partial_links && if (lnk == NULL || !replace_partial_links)
(lnk->flags & LINK_PARTIALLY_SPECIFIED || lnk->server != NULL)) { return (lnk);
struct in_addr src_addr;
u_short src_port;
if (lnk->server != NULL) { /* LSNAT link */ if (lnk->server != NULL) { /* LSNAT link */
src_addr = lnk->server->addr; src_addr = lnk->server->addr;
src_port = lnk->server->port; src_port = lnk->server->port;
lnk->server = lnk->server->next; lnk->server = lnk->server->next;
} else { } else {
src_addr = lnk->src_addr; src_addr = lnk->src_addr;
src_port = lnk->src_port; src_port = lnk->src_port;
} }
if (link_type == LINK_SCTP) { if (link_type == LINK_SCTP) {
lnk->src_addr = src_addr; lnk->src_addr = src_addr;
lnk->src_port = src_port; lnk->src_port = src_port;
return (lnk); } else {
}
lnk = ReLink(lnk, lnk = ReLink(lnk,
src_addr, dst_addr, alias_addr, src_addr, dst_addr, alias_addr,
src_port, dst_port, alias_port, src_port, dst_port, alias_port,
link_type); link_type);
} }
return (lnk); return (lnk);
} }
Show All 15 Lines if (lnk == NULL) {
/* /*
* The following allows permanent links to be specified as * The following allows permanent links to be specified as
* using the default aliasing address (i.e. device * using the default aliasing address (i.e. device
* interface address) without knowing in advance what that * interface address) without knowing in advance what that
* address is. * address is.
*/ */
if (la->aliasAddress.s_addr != INADDR_ANY && if (la->aliasAddress.s_addr != INADDR_ANY &&
alias_addr.s_addr == la->aliasAddress.s_addr) { alias_addr.s_addr == la->aliasAddress.s_addr) {
lnk = _FindLinkIn(la, dst_addr, NO_ADDR, dst_port, alias_port, lnk = _FindLinkIn(la, dst_addr, ANY_ADDR, dst_port, alias_port,
link_type, replace_partial_links); link_type, replace_partial_links);
} }
} }
return (lnk); return (lnk);
} }
/* External routines for finding/adding links /* External routines for finding/adding links
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 LinesFindFragmentIn1(struct libalias *la, struct in_addr dst_addr,
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, dst_addr, alias_addr, lnk = FindLinkIn(la, dst_addr, alias_addr,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID, 0); LINK_FRAGMENT_ID, 0);
if (lnk == NULL) { if (lnk == NULL) {
lnk = AddLink(la, NO_ADDR, dst_addr, alias_addr, lnk = AddLink(la, ANY_ADDR, dst_addr, alias_addr,
NO_SRC_PORT, NO_DEST_PORT, ip_id, NO_SRC_PORT, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID); LINK_FRAGMENT_ID);
} }
return (lnk); return (lnk);
} }
/* Doesn't add a link if one is not found. */ /* Doesn't add a link if one is not found. */
struct alias_link * struct alias_link *
FindFragmentIn2(struct libalias *la, struct in_addr dst_addr, FindFragmentIn2(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, u_short ip_id) struct in_addr alias_addr, u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return FindLinkIn(la, dst_addr, alias_addr, return FindLinkIn(la, dst_addr, alias_addr,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID, 0); LINK_FRAGMENT_ID, 0);
} }
struct alias_link * struct alias_link *
AddFragmentPtrLink(struct libalias *la, struct in_addr dst_addr, AddFragmentPtrLink(struct libalias *la, struct in_addr dst_addr,
u_short ip_id) u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return AddLink(la, NO_ADDR, dst_addr, NO_ADDR, return AddLink(la, ANY_ADDR, dst_addr, ANY_ADDR,
NO_SRC_PORT, NO_DEST_PORT, ip_id, NO_SRC_PORT, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_PTR); LINK_FRAGMENT_PTR);
} }
struct alias_link * struct alias_link *
FindFragmentPtr(struct libalias *la, struct in_addr dst_addr, FindFragmentPtr(struct libalias *la, struct in_addr dst_addr,
u_short ip_id) u_short ip_id)
{ {
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
return FindLinkIn(la, dst_addr, NO_ADDR, return FindLinkIn(la, dst_addr, ANY_ADDR,
NO_DEST_PORT, ip_id, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_PTR, 0); LINK_FRAGMENT_PTR, 0);
} }
struct alias_link * struct alias_link *
FindProtoIn(struct libalias *la, struct in_addr dst_addr, FindProtoIn(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_char proto) u_char proto)
▲ Show 20 Lines • Show All 131 Lines • ▼ Show 20 LinesAddPptp(struct libalias *la, struct in_addr src_addr,
return (lnk); return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpOutByCallId(struct libalias *la, struct in_addr src_addr, FindPptpOutByCallId(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_int16_t src_call_id) u_int16_t src_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, 0, 0, LINK_PPTP); LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) if (lnk->src_addr.s_addr == src_addr.s_addr &&
if (lnk->link_type == LINK_PPTP &&
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->src_port == src_call_id) lnk->src_port == src_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpOutByPeerCallId(struct libalias *la, struct in_addr src_addr, FindPptpOutByPeerCallId(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_int16_t dst_call_id) u_int16_t dst_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, 0, 0, LINK_PPTP); LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) if (lnk->src_addr.s_addr == src_addr.s_addr &&
if (lnk->link_type == LINK_PPTP &&
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->dst_port == dst_call_id) lnk->dst_port == dst_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpInByCallId(struct libalias *la, struct in_addr dst_addr, FindPptpInByCallId(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_int16_t dst_call_id) u_int16_t dst_call_id)
{ {
u_int i;
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
i = StartPointIn(alias_addr, 0, LINK_PPTP);
LIST_FOREACH(lnk, &la->linkTableIn[i], list_in) LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
if (lnk->link_type == LINK_PPTP && if (lnk->dst_port == dst_call_id &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->alias_addr.s_addr == alias_addr.s_addr && lnk->alias_addr.s_addr == alias_addr.s_addr)
lnk->dst_port == dst_call_id)
break; break;
CleanupLink(la, &lnk); return (UseLink(la, lnk));
return (lnk);
} }
struct alias_link * struct alias_link *
FindPptpInByPeerCallId(struct libalias *la, struct in_addr dst_addr, FindPptpInByPeerCallId(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, struct in_addr alias_addr,
u_int16_t alias_call_id) u_int16_t alias_call_id)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, dst_addr, alias_addr, LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
0 /* any */ , alias_call_id, if (lnk->alias_port == alias_call_id &&
LINK_PPTP, 0); lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->alias_addr.s_addr == alias_addr.s_addr)
break;
return (lnk); return (lnk);
} }
struct alias_link * struct alias_link *
FindRtspOut(struct libalias *la, struct in_addr src_addr, FindRtspOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr, struct in_addr dst_addr,
u_short src_port, u_short src_port,
Show All 30 Lines
} }
struct in_addr struct in_addr
FindOriginalAddress(struct libalias *la, struct in_addr alias_addr) FindOriginalAddress(struct libalias *la, struct in_addr alias_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, NO_ADDR, alias_addr, lnk = FindLinkIn(la, ANY_ADDR, alias_addr,
0, 0, LINK_ADDR, 0); 0, 0, LINK_ADDR, 0);
if (lnk == NULL) { if (lnk == NULL) {
la->newDefaultLink = 1; la->newDefaultLink = 1;
if (la->targetAddress.s_addr == INADDR_ANY) if (la->targetAddress.s_addr == INADDR_ANY)
return (alias_addr); return (alias_addr);
else if (la->targetAddress.s_addr == INADDR_NONE) else if (la->targetAddress.s_addr == INADDR_NONE)
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : alias_addr; la->aliasAddress : alias_addr;
Show All 15 Lines
} }
struct in_addr struct in_addr
FindAliasAddress(struct libalias *la, struct in_addr original_addr) FindAliasAddress(struct libalias *la, struct in_addr original_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkOut(la, original_addr, NO_ADDR, lnk = FindLinkOut(la, original_addr, ANY_ADDR,
0, 0, LINK_ADDR, 0); 0, 0, LINK_ADDR, 0);
if (lnk == NULL) { if (lnk == NULL) {
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : original_addr; la->aliasAddress : original_addr;
} else { } else {
if (lnk->alias_addr.s_addr == INADDR_ANY) if (lnk->alias_addr.s_addr == INADDR_ANY)
return (la->aliasAddress.s_addr != INADDR_ANY) ? return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : original_addr; la->aliasAddress : original_addr;
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
void void
SetStateIn(struct alias_link *lnk, int state) SetStateIn(struct alias_link *lnk, int state)
{ {
/* TCP input state */ /* TCP input state */
switch (state) { switch (state) {
case ALIAS_TCP_STATE_DISCONNECTED: case ALIAS_TCP_STATE_DISCONNECTED:
if (lnk->data.tcp->state.out != ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.out != ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_DEAD; lnk->expire.timeout = TCP_EXPIRE_DEAD;
else else
lnk->expire_time = TCP_EXPIRE_SINGLEDEAD; lnk->expire.timeout = TCP_EXPIRE_SINGLEDEAD;
break; break;
case ALIAS_TCP_STATE_CONNECTED: case ALIAS_TCP_STATE_CONNECTED:
if (lnk->data.tcp->state.out == ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.out == ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_CONNECTED; lnk->expire.timeout = TCP_EXPIRE_CONNECTED;
break; break;
default: default:
#ifdef _KERNEL #ifdef _KERNEL
panic("libalias:SetStateIn() unknown state"); panic("libalias:SetStateIn() unknown state");
#else #else
abort(); abort();
#endif #endif
} }
lnk->data.tcp->state.in = state; lnk->data.tcp->state.in = state;
} }
void void
SetStateOut(struct alias_link *lnk, int state) SetStateOut(struct alias_link *lnk, int state)
{ {
/* TCP output state */ /* TCP output state */
switch (state) { switch (state) {
case ALIAS_TCP_STATE_DISCONNECTED: case ALIAS_TCP_STATE_DISCONNECTED:
if (lnk->data.tcp->state.in != ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.in != ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_DEAD; lnk->expire.timeout = TCP_EXPIRE_DEAD;
else else
lnk->expire_time = TCP_EXPIRE_SINGLEDEAD; lnk->expire.timeout = TCP_EXPIRE_SINGLEDEAD;
break; break;
case ALIAS_TCP_STATE_CONNECTED: case ALIAS_TCP_STATE_CONNECTED:
if (lnk->data.tcp->state.in == ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.in == ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_CONNECTED; lnk->expire.timeout = TCP_EXPIRE_CONNECTED;
break; break;
default: default:
#ifdef _KERNEL #ifdef _KERNEL
panic("libalias:SetStateOut() unknown state"); panic("libalias:SetStateOut() unknown state");
#else #else
abort(); abort();
#endif #endif
} }
▲ Show 20 Lines • Show All 232 Lines • ▼ Show 20 Lines
SetExpire(struct alias_link *lnk, int expire) SetExpire(struct alias_link *lnk, int expire)
{ {
if (expire == 0) { if (expire == 0) {
lnk->flags &= ~LINK_PERMANENT; lnk->flags &= ~LINK_PERMANENT;
DeleteLink(&lnk); DeleteLink(&lnk);
} else if (expire == -1) { } else if (expire == -1) {
lnk->flags |= LINK_PERMANENT; lnk->flags |= LINK_PERMANENT;
} else if (expire > 0) { } else if (expire > 0) {
lnk->expire_time = expire; lnk->expire.timeout = expire;
} else { } else {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/SetExpire(): "); fprintf(stderr, "PacketAlias/SetExpire(): ");
fprintf(stderr, "error in expire parameter\n"); fprintf(stderr, "error in expire parameter\n");
#endif #endif
} }
} }
▲ Show 20 Lines • Show All 187 Lines • ▼ Show 20 Lines
LibAliasAddServer(struct libalias *la, struct alias_link *lnk, struct in_addr addr, u_short port) LibAliasAddServer(struct libalias *la, struct alias_link *lnk, struct in_addr addr, u_short port)
{ {
struct server *server; struct server *server;
int res; int res;
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
(void)la; (void)la;
switch (lnk->link_type) {
case LINK_PPTP:
server = NULL;
break;
default:
server = malloc(sizeof(struct server)); server = malloc(sizeof(struct server));
break;
}
if (server != NULL) { if (server != NULL) {
struct server *head; struct server *head;
server->addr = addr; server->addr = addr;
server->port = port; server->port = port;
head = lnk->server; head = lnk->server;
if (head == NULL) if (head == NULL) {
server->next = server; server->next = server;
else { /* not usable for outgoing connections */
LIST_REMOVE(lnk, all.out);
} else {
struct server *s; struct server *s;
for (s = head; s->next != head; s = s->next) for (s = head; s->next != head; s = s->next)
; ;
s->next = server; s->next = server;
server->next = head; server->next = head;
} }
lnk->server = server; lnk->server = server;
Show All 37 Lines
/* Static address translation */ /* Static address translation */
struct alias_link * struct alias_link *
LibAliasRedirectAddr(struct libalias *la, struct in_addr src_addr, LibAliasRedirectAddr(struct libalias *la, struct in_addr src_addr,
struct in_addr alias_addr) struct in_addr alias_addr)
{ {
struct alias_link *lnk; struct alias_link *lnk;
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
lnk = AddLink(la, src_addr, NO_ADDR, alias_addr, lnk = AddLink(la, src_addr, ANY_ADDR, alias_addr,
0, 0, 0, 0, 0, 0,
LINK_ADDR); LINK_ADDR);
if (lnk != NULL) { if (lnk != NULL) {
lnk->flags |= LINK_PERMANENT; lnk->flags |= LINK_PERMANENT;
} }
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
else { else {
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines#ifdef _KERNEL
LibAliasTime = time_uptime; LibAliasTime = time_uptime;
#else #else
LibAliasTime = time(NULL); LibAliasTime = time(NULL);
#endif #endif
for (i = 0; i < LINK_TABLE_OUT_SIZE; i++) for (i = 0; i < LINK_TABLE_OUT_SIZE; i++)
LIST_INIT(&la->linkTableOut[i]); LIST_INIT(&la->linkTableOut[i]);
for (i = 0; i < LINK_TABLE_IN_SIZE; i++) for (i = 0; i < LINK_TABLE_IN_SIZE; i++)
LIST_INIT(&la->linkTableIn[i]); LIST_INIT(&la->groupTableIn[i]);
LIST_INIT(&la->pptpTable);
TAILQ_INIT(&la->checkExpire); TAILQ_INIT(&la->checkExpire);
#ifdef _KERNEL #ifdef _KERNEL
AliasSctpInit(la); AliasSctpInit(la);
#endif #endif
LIBALIAS_LOCK_INIT(la); LIBALIAS_LOCK_INIT(la);
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
} else { } else {
LIBALIAS_LOCK(la); LIBALIAS_LOCK(la);
la->deleteAllLinks = 1; la->deleteAllLinks = 1;
CleanupAliasData(la); CleanupAliasData(la);
la->deleteAllLinks = 0; la->deleteAllLinks = 0;
#ifdef _KERNEL #ifdef _KERNEL
AliasSctpTerm(la); AliasSctpTerm(la);
AliasSctpInit(la); AliasSctpInit(la);
#endif #endif
} }
la->aliasAddress.s_addr = INADDR_ANY; la->aliasAddress.s_addr = INADDR_ANY;
la->targetAddress.s_addr = INADDR_ANY; la->targetAddress.s_addr = INADDR_ANY;
la->aliasPortLower = 0x8000;
la->aliasPortLength = 0x8000;
la->icmpLinkCount = 0; la->icmpLinkCount = 0;
la->udpLinkCount = 0; la->udpLinkCount = 0;
la->tcpLinkCount = 0; la->tcpLinkCount = 0;
la->sctpLinkCount = 0; la->sctpLinkCount = 0;
la->pptpLinkCount = 0; la->pptpLinkCount = 0;
la->protoLinkCount = 0; la->protoLinkCount = 0;
la->fragmentIdLinkCount = 0; la->fragmentIdLinkCount = 0;
▲ Show 20 Lines • Show All 380 Lines • Show Last 20 Lines
View Options

multimedia/libxine/files/patch-include-xine-xine_internal.h

Loading...
View Options

multimedia/libxine/files/patch-include-xine-xineutils.h

Loading...
View Options

multimedia/libxine/files/patch-src-audio_dec-xine_lpcm_decoder.c

Loading...
View Options

multimedia/libxine/files/patch-src-combined-ffmpeg-Makefile.in.diff

Loading...
View Options

multimedia/libxine/files/patch-src-libw32dll-wine-registry.c

Loading...
View Options

multimedia/libxine/files/patch-src-post-deinterlace-plugins-greedy2frame_template_sse2.c

Loading...
View Options

multimedia/libxine/files/patch-src-post-planar-eq2.c

Loading...
View Options

multimedia/libxine/files/patch-src-vdr-input_vdr.c

Loading...
View Options

multimedia/libxine/pkg-plist

Loading...