File: README

package info (click to toggle)
socket 1.1-10
  • links: PTS
  • area: main
  • in suites: bullseye, buster, jessie, jessie-kfreebsd, sid, squeeze, stretch, wheezy
  • size: 128 kB
  • ctags: 81
  • sloc: ansic: 947; makefile: 159; sh: 18
file content (171 lines) | stat: -rw-r--r-- 6,208 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
Hey Emacs, this is -*- text -*-.

This is the README file for Socket-1.1.  

For information on how to build and install Socket, read the file
INSTALL.  Please read the file COPYRIGHT about the terms under which
this program is licensed to you.


What is it?

The program Socket implements access to TCP or UNIX sockets from shell level.
First written for the need to open a server socket and read and write
to the socket interactively for testing purposes, it quickly evolved
into a generic tool providing the socket interface for shell script
and interactive use.


Client mode

In client mode (which is the default) it connects to a given port at a
given host or to a given UNIX domain socket specified by a pathname on the
local filesystem(s). Data read from the socket is written to stdout, data read
from stdin is written to the socket.  When the peer closes the
connection or a signal is received, the program terminates.  An
example for this is the following command:

	% socket coma.cs.tu-berlin.de nntp

This connects to the host coma.cs.tu-berlin.de at the nntp port
(provided these two names can be resolved through gethostbyname(3) and
getservbyname(3)).  The user can now issue commands to the NNTP
server, any output from the server is written to the user's terminal.


Server mode

In server mode (indicated by the "-s" command line switch) it binds a
server socket to the given port on the local host (INET sockets)
or a given pathname on the local filesystem (UNIX sockets) and accepts a
connection.  When a client connects to this socket, all data read from
the socket is written to stdout, data read from stdin is written to
the socket.  For example, the command

	% socket -s 3917

accepts a connection on port 3917.  


Restricting data flow

It is not always desirable to have data flow in both directions, e.g.
when the program is running in the background, it would be stopped if
it tried to read from the terminal.  So the user can advise the program
only to read from the socket ("-r") or only to write to the socket
("-w").  Especially when Socket executes a program (see below), it is
important *not* to write to the program's stdin if the program doesn't
read it.  This is the main reason why I added this option.


Closing connection on EOF

For non-interactive use it is not always clear when to close the
network connection; this is still an unsolved problem.  But often it
will be enough to close the connection when some data has been written
to the socket.  In this case the "quit" switch ("-q") can be used:
when an end-of-file condition on stdin occurs, Socket closes the
connection.


Executing a program

An interesting use of a server socket is to execute a program when a
client connects to it.  This done with the "-p" switch.  Stdin,
stdout, and stderr of the program are read from resp. written to the
socket.  Since the server is usually expected to accept another
connection after a connection has been closed, the "loop" switch
("-l") makes it do exactly that.


CRLF conversion

The Internet protocols specify a CRLF sequence (Carriage Return
Linefeed) to terminate a line, whereas UNIX uses only a single LF.  If
the user specifies the "crlf" switch ("-c"), all CRLF sequences that
are read from the socket are converted to a single LF on output.  All
single LFs on input are converted to a CRLF sequence when written to
the socket.


Background mode

It may be desirable for a server program to run in background. For
that purpose the "background" switch ("-b") is provided.  If it is
set, Socket runs in background, detaches itself from the controlling
tty, closes the file descriptors associated with the tty, and changes
it current directory to the root directory.  It is still possible to
redirect the standard file descriptors to a file.


Forking child to handle connection

Often one wants the server to be able to respond to another client
immediately, even before the connection to the previous client has
been closed.  For this case, Socket can fork a client to handle a
connection while the father process already accepts the next
connection.  To get this behaviour, specify the "-f" option.


With all these options, a typical server call would look like

	% socket -bcfslqp program port

Gee, I know that's a lot of options for the standard case, but I
really want to make all these things *optional*.


Verbose

At last, there is also a "verbose" option ("-v"). If this option is
specified, a message is given for each opening and closing of a
connection.  This is convenient especially in interactive use, but can
also provide some kind of logging.  See fingerd.sh for an example.


WARNING

Nothing prevents you from using Socket like this:

	% socket -slqp sh 5678

THIS IS DANGEROUS! If your machine is connected to the Internet,
*anyone* on the Internet can connect to this server and issue shell
commands to your shell.  These commands are executed with your user
ID.  Some people may think of this program as a BAD THING, because it
allows its user to open his machine for world-wide access to all kinds
of malicious crackers, crashers, etc.  I don't know if I should
consider this as a real security risk or not.  Anyway, it is not my
program which is so dangerous -- anyone with moderate programming
skill can write a something like this.

Another problem is that any server program that uses Socket may not be
secure.  I tried to avoid any holes -- especially that one that made
fingerd vulnerable to the attack of Morris' Internet Worm, but I don't
give any warranty.  Also the program run by Socket may have security
holes.

I would like to hear your opinion about this topic.  Do you consider it
a security risk to have a program like Socket around?


Sample programs

I included two sample programs, which mimic the behavior of finger(1)
and fingerd(8), implemented as shell scripts using Socket.  rfinger.sh
can only finger remote hosts.  fingerd.sh is RFC 1288 compliant and
can be used independently of inetd(8).


Comments

Please send any comments, suggestions, bug reports etc. to me:

    Juergen Nickelsen
    Sekr. FR 5-6
    TU Berlin
    Franklinstr. 28-29
    1000 Berlin 10
    Germany

    <nickel@cs.tu-berlin.de>