Programming in Linux

Man page: Vim

2009-06-26T11:48:00.000-07:00

NAME
vim - Vi IMproved, a programmers text editor

SYNOPSIS
vim [options] [file ..]
vim [options] -
vim [options] -t tag
vim [options] -q [errorfile]

ex
view
gvim gview evim eview
rvim rview rgvim rgview

DESCRIPTION
Vim is a text editor that is upwards compatible to Vi. It can
be used to edit all kinds of plain text. It is especially
useful for editing programs.
There are a lot of enhancements above Vi: multi level undo,
multi windows and buffers, syntax highlighting, command line
editing, filename completion, on-line help, visual selection,
etc.. See ":help vi_diff.txt" for a summary of the differ‐
ences between Vim and Vi.

While running Vim a lot of help can be obtained from the on-
line help system, with the ":help" command. See the ON-LINE
HELP section below.

Most often Vim is started to edit a single file with the com‐
mand

vim file

More generally Vim is started with:

vim [options] [filelist]
If the filelist is missing, the editor will start with an
empty buffer. Otherwise exactly one out of the following four
may be used to choose one or more files to be edited.

file .. A list of filenames. The first one will be the
current file and read into the buffer. The cursor
will be positioned on the first line of the
buffer. You can get to the other files with the
":next" command. To edit a file that starts with
a dash, precede the filelist with "--".

- The file to edit is read from stdin. Commands are
read from stderr, which should be a tty.

-t {tag} The file to edit and the initial cursor position
depends on a "tag", a sort of goto label. {tag}
is looked up in the tags file, the associated file
becomes the current file and the associated com‐
mand is executed. Mostly this is used for C pro‐
grams, in which case {tag} could be a function
name. The effect is that the file containing that
function becomes the current file and the cursor
is positioned on the start of the function. See
":help tag-commands".

-q [errorfile]
Start in quickFix mode. The file [errorfile] is
read and the first error is displayed. If [error‐
file] is omitted, the filename is obtained from
the ’errorfile’ option (defaults to "AztecC.Err"
for the Amiga, "errors.err" on other systems).
Further errors can be jumped to with the ":cn"
command. See ":help quickfix".

Vim behaves differently, depending on the name of the command
(the executable may still be the same file).

vim The "normal" way, everything is default.

ex Start in Ex mode. Go to Normal mode with the ":vi"
command. Can also be done with the "-e" argument.
view Start in read-only mode. You will be protected from
writing the files. Can also be done with the "-R"
argument.

gvim gview
The GUI version. Starts a new window. Can also be
done with the "-g" argument.

evim eview
The GUI version in easy mode. Starts a new window.
Can also be done with the "-y" argument.

rvim rview rgvim rgview
Like the above, but with restrictions. It will not
be possible to start shell commands, or suspend Vim.
Can also be done with the "-Z" argument.

OPTIONS
The options may be given in any order, before or after file‐
names. Options without an argument can be combined after a
single dash.

+[num] For the first file the cursor will be positioned
on line "num". If "num" is missing, the cursor
will be positioned on the last line.

+/{pat} For the first file the cursor will be positioned
on the first occurrence of {pat}. See ":help
search-pattern" for the available search patterns.

+{command}

-c {command}
{command} will be executed after the first file
has been read. {command} is interpreted as an Ex
command. If the {command} contains spaces it must
be enclosed in double quotes (this depends on the
shell that is used). Example: Vim "+set si"
main.c
Note: You can use up to 10 "+" or "-c" commands.
-S {file} {file} will be sourced after the first file has
been read. This is equivalent to -c "source
{file}". {file} cannot start with ’-’. If {file}
is omitted "Session.vim" is used (only works when
-S is the last argument).

--cmd {command}
Like using "-c", but the command is executed just
before processing any vimrc file. You can use up
to 10 of these commands, independently from "-c"
commands.

-A If Vim has been compiled with ARABIC support for
editing right-to-left oriented files and Arabic
keyboard mapping, this option starts Vim in Arabic
mode, i.e. ’arabic’ is set. Otherwise an error
message is given and Vim aborts.

-b Binary mode. A few options will be set that makes
it possible to edit a binary or executable file.
-C Compatible. Set the ’compatible’ option. This
will make Vim behave mostly like Vi, even though a
.vimrc file exists.

-d Start in diff mode. There should be two, three or
four file name arguments. Vim will open all the
files and show differences between them. Works
like vimdiff(1).

-d {device} Open {device} for use as a terminal. Only on the
Amiga. Example: "-d con:20/30/600/150".

-D Debugging. Go to debugging mode when executing
the first command from a script.

-e Start Vim in Ex mode, just like the executable was
called "ex".

-E Start Vim in improved Ex mode, just like the exe‐
cutable was called "exim".
-f Foreground. For the GUI version, Vim will not
fork and detach from the shell it was started in.
On the Amiga, Vim is not restarted to open a new
window. This option should be used when Vim is
executed by a program that will wait for the edit
session to finish (e.g. mail). On the Amiga the
":sh" and ":!" commands will not work.

--nofork Foreground. For the GUI version, Vim will not
fork and detach from the shell it was started in.

-F If Vim has been compiled with FKMAP support for
editing right-to-left oriented files and Farsi
keyboard mapping, this option starts Vim in Farsi
mode, i.e. ’fkmap’ and ’rightleft’ are set. Oth‐
erwise an error message is given and Vim aborts.

-g If Vim has been compiled with GUI support, this
option enables the GUI. If no GUI support was
compiled in, an error message is given and Vim
aborts.

-h Give a bit of help about the command line argu‐
ments and options. After this Vim exits.

-H If Vim has been compiled with RIGHTLEFT support
for editing right-to-left oriented files and
Hebrew keyboard mapping, this option starts Vim in
Hebrew mode, i.e. ’hkmap’ and ’rightleft’ are set.
Otherwise an error message is given and Vim
aborts.

-i {viminfo}
When using the viminfo file is enabled, this
option sets the filename to use, instead of the
default "~/.viminfo". This can also be used to
skip the use of the .viminfo file, by giving the
name "NONE".

-L Same as -r.

-l Lisp mode. Sets the ’lisp’ and ’showmatch’
options on.

-m Modifying files is disabled. Resets the ’write’
option. You can still modify the buffer, but
writing a file is not possible.

-M Modifications not allowed. The ’modifiable’ and
’write’ options will be unset, so that changes are
not allowed and files can not be written. Note
that these options can be set to enable making
modifications.

-N No-compatible mode. Reset the ’compatible’
option. This will make Vim behave a bit better,
but less Vi compatible, even though a .vimrc file
does not exist.

-n No swap file will be used. Recovery after a crash
will be impossible. Handy if you want to edit a
file on a very slow medium (e.g. floppy). Can
also be done with ":set uc=0". Can be undone with
":set uc=200".

-nb Become an editor server for NetBeans. See the
docs for details.

-o[N] Open N windows stacked. When N is omitted, open
one window for each file.

-O[N] Open N windows side by side. When N is omitted,
open one window for each file.

-p[N] Open N tab pages. When N is omitted, open one tab
page for each file.

-R Read-only mode. The ’readonly’ option will be
set. You can still edit the buffer, but will be
prevented from accidently overwriting a file. If
you do want to overwrite a file, add an exclama‐
tion mark to the Ex command, as in ":w!". The -R
option also implies the -n option (see below).
The ’readonly’ option can be reset with ":set
noro". See ":help ’readonly’".

-r List swap files, with information about using them
for recovery.

-r {file} Recovery mode. The swap file is used to recover a
crashed editing session. The swap file is a file
with the same filename as the text file with
".swp" appended. See ":help recovery".

-s Silent mode. Only when started as "Ex" or when
the "-e" option was given before the "-s" option.

-s {scriptin}
The script file {scriptin} is read. The charac‐
ters in the file are interpreted as if you had
typed them. The same can be done with the command
":source! {scriptin}". If the end of the file is
reached before the editor exits, further
characters are read from the keyboard.
-T {terminal}
Tells Vim the name of the terminal you are using.
Only required when the automatic way doesn’t work.
Should be a terminal known to Vim (builtin) or
defined in the termcap or terminfo file.

-u {vimrc} Use the commands in the file {vimrc} for initial‐
izations. All the other initializations are
skipped. Use this to edit a special kind of
files. It can also be used to skip all initial‐
izations by giving the name "NONE". See ":help
initialization" within vim for more details.

-U {gvimrc} Use the commands in the file {gvimrc} for GUI ini‐
tializations. All the other GUI initializations
are skipped. It can also be used to skip all GUI
initializations by giving the name "NONE". See
":help gui-init" within vim for more details.

-V[N] Verbose. Give messages about which files are
sourced and for reading and writing a viminfo
file. The optional number N is the value for
’verbose’. Default is 10.

-v Start Vim in Vi mode, just like the executable was
called "vi". This only has effect when the exe‐
cutable is called "ex".

-w {scriptout}
All the characters that you type are recorded in
the file {scriptout}, until you exit Vim. This is
useful if you want to create a script file to be
used with "vim -s" or ":source!". If the
{scriptout} file exists, characters are appended.

-W {scriptout}
Like -w, but an existing file is overwritten.

-x Use encryption when writing files. Will prompt
for a crypt key.

-X Don’t connect to the X server. Shortens startup
time in a terminal, but the window title and clip‐
board will not be used.

-y Start Vim in easy mode, just like the executable
was called "evim" or "eview". Makes Vim behave
like a click-and-type editor.

-Z Restricted mode. Works like the executable starts
with "r".

-- Denotes the end of the options. Arguments after
this will be handled as a file name. This can be
used to edit a filename that starts with a ’-’.

--echo-wid GTK GUI only: Echo the Window ID on stdout.

--help Give a help message and exit, just like "-h".

--literal Take file name arguments literally, do not expand
wildcards. This has no effect on Unix where the
shell expands wildcards.

--noplugin Skip loading plugins. Implied by -u NONE.

--remote Connect to a Vim server and make it edit the files
given in the rest of the arguments. If no server
is found a warning is given and the files are
edited in the current Vim.

--remote-expr {expr}
Connect to a Vim server, evaluate {expr} in it and
print the result on stdout.

--remote-send {keys}
Connect to a Vim server and send {keys} to it.

--remote-silent
As --remote, but without the warning when no
server is found.

--remote-wait
As --remote, but Vim does not exit until the files
have been edited.

--remote-wait-silent
As --remote-wait, but without the warning when no
server is found.

--serverlist
List the names of all Vim servers that can be
found.

--servername {name}
Use {name} as the server name. Used for the cur‐
rent Vim, unless used with a --remote argument,
then it’s the name of the server to connect to.

--socketid {id}
GTK GUI only: Use the GtkPlug mechanism to run
gvim in another window.

--version Print version information and exit.

HowTo Create your Own Usplash

2009-04-29T23:23:00.000-07:00

I have moved the post to http://linuxandmicrocontrollertips.blogspot.com/2009/06/howto-create-your-own-usplash.html

HOWTO create your own GDM Themes

2009-04-18T02:56:00.000-07:00

I have moved this post to http://linuxandmicrocontrollertips.blogspot.com/2009/06/howto-create-your-own-gdm-themes.html

Man page - write

2008-11-24T18:06:00.000-08:00

NAME
write - write to a file descriptor

SYNOPSIS
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);

DESCRIPTION
write() writes up to count bytes from the buffer pointed buf to the
file referred to by the file descriptor fd.

The number of bytes written may be less than count if, for example,
there is insufficient space on the underlying physical medium, or the
RLIMIT_FSIZE resource limit is encountered (see setrlimit(2)), or the
call was interrupted by a signal handler after having written less than
count bytes. (See also pipe(7).)

For a seekable file (i.e., one to which lseek(2) may be applied, for
example, a regular file) writing takes place at the current file off
set, and the file offset is incremented by the number of bytes actually
written. If the file was open(2)ed with O_APPEND, the file offset is
first set to the end of the file before writing. The adjustment of the
file offset and the write operation are performed as an atomic step.

POSIX requires that a read(2) which can be proved to occur after a
write() has returned returns the new data. Note that not all file sys
tems are POSIX conforming.

RETURN VALUE
On success, the number of bytes written is returned (zero indicates
nothing was written). On error, -1 is returned, and errno is set
appropriately.

If count is zero and fd refers to a regular file, then write() may
return a failure status if one of the errors below is detected. If no
errors are detected, 0 will be returned without causing any other
effect. If count is zero and fd refers to a file other than a regular
file, the results are not specified.

ERRORS
EAGAIN The file descriptor fd has been marked non-blocking (O_NONBLOCK)
and the write would block.

EBADF fd is not a valid file descriptor or is not open for writing.

EFAULT buf is outside your accessible address space.

EFBIG An attempt was made to write a file that exceeds the implementa
tion-defined maximum file size or the processs file size limit,
or to write at a position past the maximum allowed offset.

EINTR The call was interrupted by a signal before any data was writ
ten.

EINVAL fd is attached to an object which is unsuitable for writing; or
the file was opened with the O_DIRECT flag, and either the
address specified in buf, the value specified in count, or the
current file offset is not suitably aligned.

EIO A low-level I/O error occurred while modifying the inode.

ENOSPC The device containing the file referred to by fd has no room for
the data.

EPIPE fd is connected to a pipe or socket whose reading end is closed.
When this happens the writing process will also receive a SIG
PIPE signal. (Thus, the write return value is seen only if the
program catches, blocks or ignores this signal.)

Other errors may occur, depending on the object connected to fd.

CONFORMING TO
SVr4, 4.3BSD, POSIX.1-2001.

Under SVr4 a write may be interrupted and return EINTR at any point,
not just before any data is written.

NOTES
A successful return from write() does not make any guarantee that data
has been committed to disk. In fact, on some buggy implementations, it
does not even guarantee that space has successfully been reserved for
the data. The only way to be sure is to call fsync(2) after you are
done writing all your data.

If a write() is interrupted by a signal handler before any bytes are
written, then the call fails with the error EINTR; if it is interrupted
after at least one byte has been written, the call succeeds, and
returns the number of bytes written.

SEE ALSO
close(2), fcntl(2), fsync(2), ioctl(2), lseek(2), open(2), pwrite(2),
read(2), select(2), writev(2), fwrite(3)

Man page - wait, waitpid, waitid

2008-11-24T17:44:00.000-08:00

NAME
wait, waitpid, waitid - wait for process to change state

SYNOPSIS
#include <sys/types.h>
#include <sys/wait.h>

pid_t wait(int *status);

pid_t waitpid(pid_t pid, int *status, int options);

int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);

Feature Test Macro Requirements for glibc (see feature_test_macros(7)):

waitid(): _SVID_SOURCE || _XOPEN_SOURCE

DESCRIPTION
All of these system calls are used to wait for state changes in a child of the calling process, and obtain information about the child whose
state has changed. A state change is considered to be: the child terminated; the child was stopped by a signal; or the child was resumed by a signal. In the case of a terminated child, performing a wait allows the system to release the resources associated with the child; if a wait is not performed, then terminated the child remains in a "zombie" state (see NOTES below).

If a child has already changed state, then these calls return immediately. Otherwise they block until either a child changes state or a signal handler interrupts the call (assuming that system calls are not automatically restarted using the SA_RESTART flag of sigaction(2)). In the remainder of this page, a child whose state has changed and which has not yet been waited upon by one of these system calls is termed waitable.

wait() and waitpid()
The wait() system call suspends execution of the calling process until one of its children terminates. The call wait(&status) is equivalent
to:
waitpid(-1, &status, 0);

The waitpid() system call suspends execution of the calling process until a child specified by pid argument has changed state. By default, waitpid() waits only for terminated children, but this behavior is modifiable via the options argument, as described below.

The value of pid can be:

< -1 meaning wait for any child process whose process group ID is equal to the absolute value of pid.

-1 meaning wait for any child process.

0 meaning wait for any child process whose process group ID is equal to that of the calling process.

> 0 meaning wait for the child whose process ID is equal to the value of pid.

The value of options is an OR of zero or more of the following constants:

WNOHANG return immediately if no child has exited.

WUNTRACED also return if a child has stopped (but not traced via ptrace(2)). Status for traced children which have stopped is provided even if this option is not specified.

WCONTINUED (Since Linux 2.6.10) also return if a stopped child has been resumed by delivery of SIGCONT.

(For Linux-only options, see below.)

The WUNTRACED and WCONTINUED options are only effective if the SA_NOCLDSTOP flag has not been set for the SIGCHLD signal (see sigaction(2)).

If status is not NULL, wait() and waitpid() store status information in the int to which it points. This integer can be inspected with the following macros (which take the integer itself as an argument, not a pointer to it, as is done in wait() and waitpid()!):

WIFEXITED(status)
returns true if the child terminated normally, that is, by calling exit(3) or _exit(2), or by returning from main().

WEXITSTATUS(status)
returns the exit status of the child. This consists of the least significant 8 bits of the status argument that the child specified in a call to exit(3) or _exit(2) or as the argument for a return statement in main(). This macro should only be employed if WIFEXITED returned true.

WIFSIGNALED(status)
returns true if the child process was terminated by a signal.

WTERMSIG(status)
returns the number of the signal that caused the child process to terminate. This macro should only be employed if WIFSIGNALED returned true.

WCOREDUMP(status)
returns true if the child produced a core dump. This macro should only be employed if WIFSIGNALED returned true. This macro is not specified in POSIX.1-2001 and is not available on some Unix implementations (e.g., AIX, SunOS). Only use this enclosed in #ifdef WCOREDUMP ... #endif.

WIFSTOPPED(status)
returns true if the child process was stopped by delivery of a signal; this is only possible if the call was done using WUNTRACED or when the child is being traced (see ptrace(2)).

WSTOPSIG(status)
returns the number of the signal which caused the child to stop. This macro should only be employed if WIFSTOPPED returned true.

WIFCONTINUED(status)
(Since Linux 2.6.10) returns true if the child process was resumed by delivery of SIGCONT.

waitid()
The waitid() system call (available since Linux 2.6.9) provides more precise control over which child state changes to wait for.

The idtype and id arguments select the child(ren) to wait for, as follows:

idtype == P_PID
Wait for the child whose process ID matches id.

idtype == P_PGID
Wait for any child whose process group ID matches id.

idtype == P_ALL
Wait for any child; id is ignored.

The child state changes to wait for are specified by ORing one or more of the following flags in options:

WEXITED Wait for children that have terminated.

WSTOPPED Wait for children that have been stopped by delivery of a signal.

WCONTINUED Wait for (previously stopped) children that have been resumed by delivery of SIGCONT.

The following flags may additionally be ORed in options:

WNOHANG As for waitpid().

WNOWAIT Leave the child in a waitable state; a later wait call can be used to again retrieve the child status information.

Upon successful return, waitid() fills in the following fields of the siginfo_t structure pointed to by infop:

si_pid The process ID of the child.

si_uid The real user ID of the child. (This field is not set on most other implementations.)

si_signo Always set to SIGCHLD.

si_status Either the exit status of the child, as given to _exit(2)(or exit(3)), or the signal that caused the child to terminate, stop, or continue. The si_code field can be used to determine how to interpret this field.

si_code Set to one of: CLD_EXITED (child called _exit(2)); CLD_KILLED (child killed by signal); CLD_STOPPED (child stopped by signal); or CLD_CONTINUED (child continued by SIGCONT).

If WNOHANG was specified in options and there were no children in a waitable state, then waitid() returns 0 immediately and the state of the siginfo_t structure pointed to by infop is unspecified. To distinguish this case from that where a child was in a waitable state, zero out the si_pid field before the call and check for a nonzero value in this field after the call returns.

RETURN VALUE
wait(): on success, returns the process ID of the terminated child; on error, -1 is returned.

waitpid(): on success, returns the process ID of the child whose state has changed; if WNOHANG was specified and one or more child(ren) speci
fied by pid exist, but have not yet changed state, then 0 is returned. On error, -1 is returned.

waitid(): returns 0 on success or if WNOHANG was specified and no child(ren) specified by id has yet changed state; on error, -1 is
returned. Each of these calls sets errno to an appropriate value in the case of an error.

ERRORS
ECHILD (for wait()) The calling process does not have any unwaited-for children.

ECHILD (for waitpid() or waitid()) The process specified by pid (waitpid()) or idtype and id (waitid()) does not exist or is not a
child of the calling process. (This can happen for ones own child if the action for SIGCHLD is set to SIG_IGN. See also the
Linux Notes section about threads.)

EINTR WNOHANG was not set and an unblocked signal or a SIGCHLD was caught.

EINVAL The options argument was invalid.

CONFORMING TO
SVr4, 4.3BSD, POSIX.1-2001.

NOTES
A child that terminates, but has not been waited for becomes a "zombie". The kernel maintains a minimal set of information about the zombie process (PID, termination status, resource usage information) in order to allow the parent to later perform a wait to obtain information about the child. As long as a zombie is not removed from the system via a wait, it will consume a slot in the kernel process table, and if this table fills, it will not be possible to create further processes. If a parent process terminates, then its "zombie" children (if any) are adopted by init(8), which automatically performs a wait to remove the zombies.

POSIX.1-2001 specifies that if the disposition of SIGCHLD is set to SIG_IGN or the SA_NOCLDWAIT flag is set for SIGCHLD (see sigaction(2)),
then children that terminate do not become zombies and a call to wait() or waitpid() will block until all children have terminated, and then
fail with errno set to ECHILD. (The original POSIX standard left the behavior of setting SIGCHLD to SIG_IGN unspecified.) Linux 2.6 con
forms to this specification. However, Linux 2.4 (and earlier) doesnot: if a wait() or waitpid() call is made while SIGCHLD is being
ignored, the call behaves just as though SIGCHLD were not being ignored, that is, the call blocks until the next child terminates and
then returns the process ID and status of that child.

Linux Notes
In the Linux kernel, a kernel-scheduled thread is not a distinct construct from a process. Instead, a thread is simply a process that is
created using the Linux-unique clone(2) system call; other routines such as the portable pthread_create(3) call are implemented using
clone(2). Before Linux 2.4, a thread was just a special case of a process, and as a consequence one thread could not wait on the children of
another thread, even when the latter belongs to the same thread group. However, POSIX prescribes such functionality, and since Linux 2.4 a
thread can, and by default will, wait on children of other threads in the same thread group.

The following Linux-specific options are for use with children created using clone(2); they cannot be used with waitid():

__WCLONE
Wait for "clone" children only. If omitted then wait for "non-clone" children only. (A "clone" child is one which delivers no
signal, or a signal other than SIGCHLD to its parent upon termination.) This option is ignored if __WALL is also speci
fied.

__WALL (Since Linux 2.4) Wait for all children, regardless of type ("clone" or "non-clone").

__WNOTHREAD
(Since Linux 2.4) Do not wait for children of other threads in the same thread group. This was the default before Linux 2.4.

EXAMPLE
The following program demonstrates the use of fork(2) and waitpid().The program creates a child process. If no command-line argument is
supplied to the program, then the child suspends its execution using pause(2), to allow the user to send signals to the child. Otherwise,
if a command-line argument is supplied, then the child exits immediately, using the integer supplied on the command line as the exit sta
tus. The parent process executes a loop that monitors the child using waitpid(), and uses the W*() macros described above to analyze the wait
status value.

The following shell session demonstrates the use of the program:

$ ./a.out &
Child PID is 32360
[1] 32359
$ kill -STOP 32360
stopped by signal 19
$ kill -CONT 32360
continued
$ kill -TERM 32360
killed by signal 15
[1]+ Done ./a.out
$

#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>

int
main(int argc, char *argv[])
{
pid_t cpid, w;
int status;

cpid = fork();
if (cpid == -1) {
perror("fork");
exit(EXIT_FAILURE);
}

if (cpid == 0) { /* Code executed by child */
printf("Child PID is %ld\n", (long) getpid());
if (argc == 1)
pause(); /* Wait for signals */
_exit(atoi(argv[1]));

} else { /* Code executed by parent */
do {
w = waitpid(cpid, &status, WUNTRACED | WCONTINUED);
if (w == -1) {
perror("waitpid");
exit(EXIT_FAILURE);
}

if (WIFEXITED(status)) {
printf("exited, status=%d\n", WEXITSTATUS(status));
} else if (WIFSIGNALED(status)) {
printf("killed by signal %d\n", WTERMSIG(status));
} else if (WIFSTOPPED(status)) {
printf("stopped by signal %d\n", WSTOPSIG(status));
} else if (WIFCONTINUED(status)) {
printf("continued\n");
}
} while (!WIFEXITED(status) && !WIFSIGNALED(status));
exit(EXIT_SUCCESS);
}
}

SEE ALSO
_exit(2), clone(2), fork(2), kill(2), ptrace(2), sigaction(2), signal(2), wait4(2), pthread_create(3), credentials(7), signal(7)

Man page - system

2008-11-24T17:41:00.001-08:00

NAME
system - execute a shell command

SYNOPSIS
#include <stdlib.h>

int system(const char *command);

DESCRIPTION
system() executes a command specified in command by calling /bin/sh -c
command, and returns after the command has been completed. During exe‐
cution of the command, SIGCHLD will be blocked, and SIGINT and SIGQUIT
will be ignored.

RETURN VALUE
The value returned is -1 on error (e.g. fork(2) failed), and the
return status of the command otherwise. This latter return status is
in the format specified in wait(2). Thus, the exit code of the command
will be WEXITSTATUS(status). In case /bin/sh could not be executed,
the exit status will be that of a command that does exit(127).

If the value of command is NULL, system() returns nonzero if the shell
is available, and zero if not.

system() does not affect the wait status of any other children.

CONFORMING TO
C89, C99, POSIX.1-2001.

NOTES
If the _XOPEN_SOURCE feature test macro is defined, then the macros
described in wait(2) (WEXITSTATUS(), etc.) are made available when
including <stdlib.h>.

As mentioned, system() ignores SIGINT and SIGQUIT. This may make pro‐
grams that call it from a loop uninterruptible, unless they take care
themselves to check the exit status of the child. E.g.

while (something) {
int ret = system("foo");

if (WIFSIGNALED(ret) &&
(WTERMSIG(ret) == SIGINT || WTERMSIG(ret) == SIGQUIT))
break;
}

Do not use system() from a program with set-user-ID or set-group-ID
privileges, because strange values for some environment variables might
be used to subvert system integrity. Use the exec(3) family of func‐
tions instead, but not execlp(3) or execvp(3). system() will not, in
fact, work properly from programs with set-user-ID or set-group-ID
privileges on systems on which /bin/sh is bash version 2, since bash 2
drops privileges on startup. (Debian uses a modified bash which does
not do this when invoked as sh.)

In versions of glibc before 2.1.3, the check for the availability of
/bin/sh was not actually performed if command was NULL; instead it was
always assumed to be available, and system() always returned 1 in this
case. Since glibc 2.1.3, this check is performed because, even though
POSIX.1-2001 requires a conforming implementation to provide a shell,
that shell may not be available or executable if the calling program
has previously called chroot(2) (which is not specified by
POSIX.1-2001).

It is possible for the shell command to return 127, so that code is not
a sure indication that the execve(2) call failed.

If the _XOPEN_SOURCE feature test macro is defined, then the macros
described in wait(2) (WEXITSTATUS(), etc.) are made available when
including <stdlib.h>.

SEE ALSO
sh(1), signal(2), wait(2), exec(3)

Man page - stdio

2008-11-24T17:31:00.000-08:00

NAME
stdio - standard input/output library functions

SYNOPSIS
#include <stdio.h>

FILE *stdin;
FILE *stdout;
FILE *stderr;

DESCRIPTION
The standard I/O library provides a simple and efficient buffered
stream I/O interface. Input and output is mapped into logical data
streams and the physical I/O characteristics are concealed. The func‐
tions and macros are listed below; more information is available from
the individual man pages.

A stream is associated with an external file (which may be a physical
device) by opening a file, which may involve creating a new file. Cre‐
ating an existing file causes its former contents to be discarded. If
a file can support positioning requests (such as a disk file, as
opposed to a terminal) then a file position indicator associated with
the stream is positioned at the start of the file (byte zero), unless
the file is opened with append mode. If append mode is used, it is
unspecified whether the position indicator will be placed at the start
or the end of the file. The position indicator is maintained by subse‐
quent reads, writes and positioning requests. All input occurs as if
the characters were read by successive calls to the fgetc(3) function;
all output takes place as if all characters were written by successive
calls to the fputc(3) function.

A file is disassociated from a stream by closing the file. Output
streams are flushed (any unwritten buffer contents are transferred to
the host environment) before the stream is disassociated from the file.
The value of a pointer to a FILE object is indeterminate after a file
is closed (garbage).

A file may be subsequently reopened, by the same or another program
execution, and its contents reclaimed or modified (if it can be reposi‐
tioned at the start). If the main function returns to its original
caller, or the exit(3) function is called, all open files are closed
(hence all output streams are flushed) before program termination.
Other methods of program termination, such as abort(3) do not bother
about closing files properly.

At program startup, three text streams are predefined and need not be
opened explicitly — standard input (for reading conventional input), —
standard output (for writing conventional input), and standard error
(for writing diagnostic output). These streams are abbreviated
stdin,stdout and stderr. When opened, the standard error stream is not
fully buffered; the standard input and output streams are fully
buffered if and only if the streams do not to refer to an interactive
device.

Output streams that refer to terminal devices are always line buffered
by default; pending output to such streams is written automatically
whenever an input stream that refers to a terminal device is read. In
cases where a large amount of computation is done after printing part
of a line on an output terminal, it is necessary to fflush(3) the stan‐
dard output before going off and computing so that the output will
appear.

The stdio library is a part of the library libc and routines are auto‐
matically loaded as needed by the compilers cc(1) and pc(1). The SYN‐
OPSIS sections of the following manual pages indicate which include
files are to be used, what the compiler declaration for the function
looks like and which external variables are of interest.

The following are defined as macros; these names may not be re-used
without first removing their current definitions with #undef: BUFSIZ,
EOF, FILENAME_MAX, FOPEN_MAX, L_cuserid, L_ctermid, L_tmpnam, NULL,
SEEK_END, SEEK_SET, SEE_CUR, TMP_MAX, clearerr, feof, ferror, fileno,
getc, getchar, putc, putchar, stderr, stdin, stdout. Function versions
of the macro functions feof, ferror, clearerr, fileno, getc, getchar,
putc, and putchar exist and will be used if the macros definitions are
explicitly removed.

List of Functions
Function ------ Description
-------------------------------------------------------------------
clearerr --- check and reset stream status
fclose ----- close a stream
fdopen ---- stream open functions
feof ------- check and reset stream status
ferror ----- check and reset stream status
fflush ----- flush a stream
fgetc ------ get next character or word from input stream
fgetpos --- reposition a stream
fgets ----- get a line from a stream
fileno ----- return the integer descriptor of the argument stream
fopen ----- stream open functions
fprintf ---- formatted output conversion
fpurge ---- flush a stream
fputc ----- output a character or word to a stream
fputs ----- output a line to a stream
fread ---- binary stream input/output
freopen --- stream open functions
fscanf --- input format conversion
fseek --- reposition a stream
fsetpos --- reposition a stream
ftell --- reposition a stream
fwrite --- binary stream input/output
getc --- get next character or word from input stream
getchar --- get next character or word from input stream
gets --- get a line from a stream
getw --- get next character or word from input stream
mktemp --- make temporary filename (unique)
perror --- system error messages
printf --- formatted output conversion
putc --- output a character or word to a stream
putchar --- output a character or word to a stream
puts --- output a line to a stream
putw --- output a character or word to a stream
remove --- remove directory entry
rewind --- reposition a stream
scanf --- input format conversion
setbuf --- stream buffering operations
setbuffer --- stream buffering operations
setlinebuf --- stream buffering operations
setvbuf --- stream buffering operations
sprintf --- formatted output conversion
sscanf --- input format conversion
strerror --- system error messages
sys_errlist --- system error messages
sys_nerr --- system error messages
tempnam --- temporary file routines
tmpfile --- temporary file routines

tmpnam --- temporary file routines
ungetc --- un-get character from input stream
vfprintf --- formatted output conversion
vfscanf --- input format conversion
vprintf --- formatted output conversion
vscanf --- input format conversion
vsprintf --- formatted output conversion
vsscanf --- input format conversion

CONFORMING TO
The stdio library conforms to C89.

SEE ALSO
close(2), open(2), read(2), write(2), stdout(3), unlocked_stdio(3)

Man page - signal

2008-11-24T17:29:00.000-08:00

NAME
signal - ANSI C signal handling

SYNOPSIS
#include <signal.h>

typedef void (*sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);

DESCRIPTION
The behavior of signal() varies across Unix versions, and has also var
ied historically across different versions of Linux. Avoid its use:
use sigaction(2) instead. See Portability below.

signal() sets the disposition of the signal signum to handler, which is
either SIG_IGN, SIG_DFL, or the address of a programmer-defined func
tion (a "signal handler").

If the signal signum is delivered to the process, then one of the fol
lowing happens:

* If the disposition is set to SIG_IGN, then the signal is ignored.

* If the disposition is set to SIG_DFL, then the default action asso
ciated with the signal (see signal(7)) occurs.

* If the disposition is set to a function, then first either the dis
position is reset to SIG_DFL, or the signal is blocked (see Porta
bility below), and then handler is called with argument signum. If
invocation of the handler caused the signal to be blocked, then the
signal is unblocked upon return from the handler.

The signals SIGKILL and SIGSTOP cannot be caught or ignored.

RETURN VALUE
signal() returns the previous value of the signal handler, or SIG_ERR
on error.

ERRORS
EINVAL signum is invalid.

CONFORMING TO
C89, C99, POSIX.1-2001.

NOTES
The effects of signal() in a multi-threaded process are unspecified.

According to POSIX, the behavior of a process is undefined after it
ignores a SIGFPE, SIGILL, or SIGSEGV signal that was not generated by
kill(2) or raise(3). Integer division by zero has undefined result.
On some architectures it will generate a SIGFPE signal. (Also dividing
the most negative integer by -1 may generate SIGFPE.) Ignoring this
signal might lead to an endless loop.

See sigaction(2) for details on what happens when SIGCHLD is set to
SIG_IGN.

See signal(7) for a list of the async-signal-safe functions that can be
safely called inside from inside a signal handler.

The use of sighandler_t is a GNU extension. Various versions of libc
predefine this type; libc4 and libc5 define SignalHandler, glibc
defines sig_t and, when _GNU_SOURCE is defined, also sighandler_t.

Portability
The original Unix signal() would reset the handler to SIG_DFL, and Sys
tem V (and the Linux kernel and libc4,5) does the same. On the other
hand, BSD does not reset the handler, but blocks new instances of this
signal from occurring during a call of the handler. The glibc2 library
follows the BSD behavior.

If one on a libc5 system includes <bsd/signal.h> instead of <signal.h>
then signal() is redefined as __bsd_signal() and signal() has the BSD
semantics. This is not recommended.

If one on a glibc2 system defines a feature test macro such as
_XOPEN_SOURCE or uses a separate sysv_signal(3) function, one obtains
classical behavior. This is not recommended.

SEE ALSO
kill(1), alarm(2), kill(2), killpg(2), pause(2), sigaction(2), sigpend
ing(2), sigprocmask(2), sigqueue(2), sigsuspend(2), bsd_signal(3),
raise(3), siginterrupt(3), sigsetops(3), sigvec(3), sysv_signal(3),
feature_test_macros(7), signal(7)

Man page - shmop, shmat, shmdt

2008-11-24T17:24:00.000-08:00

NAME
shmop, shmat, shmdt - shared memory operations

SYNOPSIS
#include <sys/types.h>
#include <sys/shm.h>

void *shmat(int shmid, const void *shmaddr, int shmflg);

int shmdt(const void *shmaddr);

DESCRIPTION
shmat() attaches the shared memory segment identified by shmid to the
address space of the calling process. The attaching address is speci‐
fied by shmaddr with one of the following criteria:

If shmaddr is NULL, the system chooses a suitable (unused) address at
which to attach the segment.

If shmaddr isn’t NULL and SHM_RND is specified in shmflg, the attach
occurs at the address equal to shmaddr rounded down to the nearest mul‐
tiple of SHMLBA. Otherwise shmaddr must be a page-aligned address at
which the attach occurs.

If SHM_RDONLY is specified in shmflg, the segment is attached for read‐
ing and the process must have read permission for the segment. Other‐
wise the segment is attached for read and write and the process must
have read and write permission for the segment. There is no notion of
a write-only shared memory segment.

The (Linux-specific) SHM_REMAP flag may be specified in shmflg to indi‐
cate that the mapping of the segment should replace any existing map‐
ping in the range starting at shmaddr and continuing for the size of
the segment. (Normally an EINVAL error would result if a mapping
already exists in this address range.) In this case, shmaddr must not
be NULL.

The brk(2) value of the calling process is not altered by the attach.
The segment will automatically be detached at process exit. The same
segment may be attached as a read and as a read-write one, and more
than once, in the process’s address space.

A successful shmat() call updates the members of the shmid_ds structure
(see shmctl(2)) associated with the shared memory segment as follows:

shm_atime is set to the current time.

shm_lpid is set to the process-ID of the calling process.

shm_nattch is incremented by one.

shmdt() detaches the shared memory segment located at the address spec‐
ified by shmaddr from the address space of the calling process. The
to-be-detached segment must be currently attached with shmaddr equal to
the value returned by the attaching shmat() call.

On a successful shmdt() call the system updates the members of the
shmid_ds structure associated with the shared memory segment as fol‐
lows:

shm_dtime is set to the current time.

shm_lpid is set to the process-ID of the calling process.

shm_nattch is decremented by one. If it becomes 0 and the seg‐
ment is marked for deletion, the segment is deleted.

After a fork(2) the child inherits the attached shared memory segments.

After an execve(2) all attached shared memory segments are detached
from the process.

Upon _exit(2) all attached shared memory segments are detached from the
process.

RETURN VALUE
On success shmat() returns the address of the attached shared memory
segment; on error (void *) -1 is returned, and errno is set to indicate
the cause of the error.

On success shmdt() returns 0; on error -1 is returned, and errno is set
to indicate the cause of the error.

ERRORS
When shmat() fails, errno is set to one of the following:

EACCES The calling process does not have the required permissions for
the requested attach type, and does not have the CAP_IPC_OWNER
capability.

EINVAL Invalid shmid value, unaligned (i.e., not page-aligned and
SHM_RND was not specified) or invalid shmaddr value, or can’t
attach segment at shmaddr, or SHM_REMAP was specified and
shmaddr was NULL.

ENOMEM Could not allocate memory for the descriptor or for the page
tables.

When shmdt() fails, errno is set as follows:

EINVAL There is no shared memory segment attached at shmaddr; or,
shmaddr is not aligned on a page boundary.

CONFORMING TO
SVr4, POSIX.1-2001.

In SVID 3 (or perhaps earlier) the type of the shmaddr argument was
changed from char * into const void *, and the returned type of shmat()
from char * into void *. (Linux libc4 and libc5 have the char * proto‐
types; glibc2 has void *.)

NOTES
Using shmat() with shmaddr equal to NULL is the preferred, portable way
of attaching a shared memory segment. Be aware that the shared memory
segment attached in this way may be attached at different addresses in
different processes. Therefore, any pointers maintained within the
shared memory must be made relative (typically to the starting address
of the segment), rather than absolute.

On Linux, it is possible to attach a shared memory segment even if it
is already marked to be deleted. However, POSIX.1-2001 does not spec‐
ify this behavior and many other implementations do not support it.

The following system parameter affects shmat():

SHMLBA Segment low boundary address multiple. Must be page
aligned. For the current implementation the SHMLBA value is
PAGE_SIZE.

The implementation places no intrinsic limit on the per-process maximum
number of shared memory segments (SHMSEG).

SEE ALSO
brk(2), mmap(2), shmctl(2), shmget(2), capabilities(7), svipc(7)

Man page - shmget

2008-11-10T09:35:00.000-08:00

NAME
shmget - allocates a shared memory segment

SYNOPSIS
#include <sys/ipc.h>
#include <sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);

DESCRIPTION
shmget() returns the identifier of the shared memory segment associated
with the value of the argument key. A new shared memory segment, with
size equal to the value of size rounded up to a multiple of PAGE_SIZE,
is created if key has the value IPC_PRIVATE or key isnt IPC_PRIVATE,
no shared memory segment corresponding to key exists, and IPC_CREAT is
specified in shmflg.

If shmflg specifies both IPC_CREAT and IPC_EXCL and a shared memory
segment already exists for key, then shmget() fails with errno set to
EEXIST. (This is analogous to the effect of the combination O_CREAT |
O_EXCL for open(2).)

The value shmflg is composed of:

IPC_CREAT to create a new segment. If this flag is not used, then
shmget() will find the segment associated with key and
check to see if the user has permission to access the seg
ment.

IPC_EXCL used with IPC_CREAT to ensure failure if the segment
already exists.

mode_flags (least significant 9 bits) specifying the permissions
granted to the owner, group, and world. These bits have
the same format, and the same meaning, as the mode argument
of open(2). Presently, the execute permissions are not
used by the system.

SHM_HUGETLB (since Linux 2.6)
Allocate the segment using "huge pages." See the kernel
source file Documentation/vm/hugetlbpage.txt for further
information.

SHM_NORESERVE (since Linux 2.6.15)
This flag serves the same purpose as the mmap(2) MAP_NORE
SERVE flag. Do not reserve swap space for this segment.
When swap space is reserved, one has the guarantee that it
is possible to modify the segment. When swap space is not
reserved one might get SIGSEGV upon a write if no physical
memory is available. See also the discussion of the file
/proc/sys/vm/overcommit_memory in proc(5).

When a new shared memory segment is created, its contents are initial
ized to zero values, and its associated data structure, shmid_ds (see
shmctl(2)), is initialized as follows:

shm_perm.cuid and shm_perm.uid are set to the effective user ID
of the calling process.

shm_perm.cgid and shm_perm.gid are set to the effective group ID
of the calling process.

The least significant 9 bits of shm_perm.mode are set to the
least significant 9 bit of shmflg.

shm_segsz is set to the value of size.

shm_lpid, shm_nattch, shm_atime and shm_dtime are set to 0.

shm_ctime is set to the current time.

If the shared memory segment already exists, the permissions are veri
fied, and a check is made to see if it is marked for destruction.

RETURN VALUE
A valid segment identifier, shmid, is returned on success, -1 on error.

ERRORS
On failure, errno is set to one of the following:

EACCES The user does not have permission to access the shared mem
ory segment, and does not have the CAP_IPC_OWNER capabil
ity.

EEXIST IPC_CREAT | IPC_EXCL was specified and the segment exists.

EINVAL A new segment was to be created and size < SHMMIN or size >
SHMMAX, or no new segment was to be created, a segment with
given key existed, but size is greater than the size of
that segment.

ENFILE The system limit on the total number of open files has been
reached.

ENOENT No segment exists for the given key, and IPC_CREAT was not
specified.

ENOMEM No memory could be allocated for segment overhead.

ENOSPC All possible shared memory IDs have been taken (SHMMNI), or
allocating a segment of the requested size would cause the
system to exceed the system-wide limit on shared memory
(SHMALL).

EPERM The SHM_HUGETLB flag was specified, but the caller was not
privileged (did not have the CAP_IPC_LOCK capability).

CONFORMING TO
SVr4, POSIX.1-2001.

SHM_HUGETLB is a non-portable Linux extension.

NOTES
IPC_PRIVATE isnt a flag field but a key_t type. If this special value
is used for key, the system call ignores everything but the least sig
nificant 9 bits of shmflg and creates a new shared memory segment (on
success).

The following limits on shared memory segment resources affect the
shmget() call:

SHMALL System wide maximum of shared memory pages (on Linux, this
limit can be read and modified via /proc/sys/kernel/shmall).

SHMMAX Maximum size in bytes for a shared memory segment: policy
dependent (on Linux, this limit can be read and modified via
/proc/sys/kernel/shmmax).

SHMMIN Minimum size in bytes for a shared memory segment: implemen
tation dependent (currently 1 byte, though PAGE_SIZE is the
effective minimum size).

SHMMNI System wide maximum number of shared memory segments: imple
mentation dependent (currently 4096, was 128 before Linux
2.3.99; on Linux, this limit can be read and modified via
/proc/sys/kernel/shmmni).

The implementation has no specific limits for the per-process maximum
number of shared memory segments (SHMSEG).

Linux Notes
Until version 2.3.30 Linux would return EIDRM for a shmget() on a
shared memory segment scheduled for deletion.

BUGS
The name choice IPC_PRIVATE was perhaps unfortunate, IPC_NEW would more
clearly show its function.

SEE ALSO
shmat(2), shmctl(2), shmdt(2), ftok(3), capabilities(7), svipc(7)

Man page - shmctl

2008-11-10T09:31:00.000-08:00

NAME
shmctl - shared memory control

SYNOPSIS
#include <sys/ipc.h>
#include <sys/shm.h>

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

DESCRIPTION
shmctl() performs the control operation specified by cmd on the shared
memory segment whose identifier is given in shmid.

The buf argument is a pointer to a shmid_ds structure, defined in
<sys/shm.h> as follows:

struct shmid_ds {
struct ipc_perm shm_perm; /* Ownership and permissions */
size_t shm_segsz; /* Size of segment (bytes) */
time_t shm_atime; /* Last attach time */
time_t shm_dtime; /* Last detach time */
time_t shm_ctime; /* Last change time */
pid_t shm_cpid; /* PID of creator */
pid_t shm_lpid; /* PID of last shmat(2)/shmdt(2) */
shmatt_t shm_nattch; /* No. of current attaches */
...
};

The ipc_perm structure is defined in <sys/ipc.h> as follows (the high
lighted fields are settable using IPC_SET):

struct ipc_perm {
key_t key; /* Key supplied to shmget(2) */
uid_t uid; /* Effective UID of owner */
gid_t gid; /* Effective GID of owner */
uid_t cuid; /* Effective UID of creator */
gid_t cgid; /* Effective GID of creator */
unsigned short mode; /* Permissions + SHM_DEST and
SHM_LOCKED flags */
unsigned short seq; /* Sequence number */
};

Valid values for cmd are:

IPC_STAT Copy information from the kernel data structure associated
with shmid into the shmid_ds structure pointed to by buf.
The caller must have read permission on the shared memory
segment.

IPC_SET Write the values of some members of the shmid_ds structure
pointed to by buf to the kernel data structure associated
with this shared memory segment, updating also its
shm_ctime member. The following fields can be changed:
shm_perm.uid, shm_perm.gid, and (the least significant 9
bits of) shm_perm.mode. The effective UID of the calling
process must match the owner (shm_perm.uid) or creator
(shm_perm.cuid) of the shared memory segment, or the caller
must be privileged.

IPC_RMID Mark the segment to be destroyed. The segment will only
actually be destroyed after the last process detaches it
(i.e., when the shm_nattch member of the associated
structure shmid_ds is zero). The caller must be the owner
or creator, or be privileged. If a segment has been marked
for destruction, then the (non-standard) SHM_DEST flag of
the shm_perm.mode field in the associated data structure
retrieved by IPC_STAT will be set.

The caller must ensure that a segment is eventually destroyed; other
wise its pages that were faulted in will remain in memory or swap.

IPC_INFO (Linux-specific)
Returns information about system-wide shared memory limits and
parameters in the structure pointed to by buf. This structure
is of type shminfo (thus, a cast is required), defined in
<sys/shm.h> if the _GNU_SOURCE feature test macro is defined:

struct shminfo {
unsigned long shmmax; /* Max. segment size */
unsigned long shmmin; /* Min. segment size; always 1 */
unsigned long shmmni; /* Max. # of segments */
unsigned long shmseg; /* Max. # of segments that a
process can attach; unused */
unsigned long shmall; /* Max. # of pages of shared
memory, system-wide */
};

The shmmni, shmmax, and shmall settings can be changed via /proc
files of the same name; see proc(5) for details.

SHM_INFO (Linux-specific)
Returns a shm_info structure whose fields contain information
about system resources consumed by shared memory. This struc
ture is defined in <sys/shm.h> if the _GNU_SOURCE feature test
macro is defined:

struct shm_info {
int used_ids; /* # of currently existing
segments */
unsigned long shm_tot; /* Total number of shared
memory pages */
unsigned long shm_rss; /* # of resident shared
memory pages */
unsigned long shm_swp; /* # of swapped shared
memory pages */
unsigned long swap_attempts; /* Unused since Linux 2.4 */
unsigned long swap_successes; /* Unused since Linux 2.4 */
};

SHM_STAT (Linux-specific)
Returns a shmid_ds structure as for IPC_STAT. However, the
shmid argument is not a segment identifier, but instead an index
into the kernels internal array that maintains information
about all shared memory segments on the system.

The caller can prevent or allow swapping of a shared memory segment
with the following cmd values:

SHM_LOCK (Linux-specific)
Prevent swapping of the shared memory segment. The caller
must fault in any pages that are required to be present
after locking is enabled. If a segment has been locked,
then the (non-standard) SHM_LOCKED flag of the
shm_perm.mode field in the associated data structure
retrieved by IPC_STAT will be set.

SHM_UNLOCK (Linux-specific)
Unlock the segment, allowing it to be swapped out.

In kernels before 2.6.10, only a privileged process could employ
SHM_LOCK and SHM_UNLOCK. Since kernel 2.6.10, an unprivileged process
can employ these operations if its effective UID matches the owner or
creator UID of the segment, and (for SHM_LOCK) the amount of memory to
be locked falls within the RLIMIT_MEMLOCK resource limit (see setr
limit(2)).

RETURN VALUE
A successful IPC_INFO or SHM_INFO operation returns the index of the
highest used entry in the kernels internal array recording information
about all shared memory segments. (This information can be used with
repeated SHM_STAT operations to obtain information about all shared
memory segments on the system.) A successful SHM_STAT operation
returns the identifier of the shared memory segment whose index was
given in shmid. Other operations return 0 on success.

On error, -1 is returned, and errno is set appropriately.

ERRORS
EACCES IPC_STAT or SHM_STAT is requested and shm_perm.mode does not
allow read access for shmid, and the calling process does
not have the CAP_IPC_OWNER capability.

EFAULT The argument cmd has value IPC_SET or IPC_STAT but the
address pointed to by buf isnt accessible.

EIDRM shmid points to a removed identifier.

EINVAL shmid is not a valid identifier, or cmd is not a valid com
mand. Or: for a SHM_STAT operation, the index value speci
fied in shmid referred to an array slot that is currently
unused.

ENOMEM (In kernels since 2.6.9), SHM_LOCK was specified and the
size of the to-be-locked segment would mean that the total
bytes in locked shared memory segments would exceed the
limit for the real user ID of the calling process. This
limit is defined by the RLIMIT_MEMLOCK soft resource limit
(see setrlimit(2)).

EOVERFLOW IPC_STAT is attempted, and the GID or UID value is too large
to be stored in the structure pointed to by buf.

EPERM IPC_SET or IPC_RMID is attempted, and the effective user ID
of the calling process is not that of the creator (found in
shm_perm.cuid), or the owner (found in shm_perm.uid), and
the process was not privileged (Linux: did not have the
CAP_SYS_ADMIN capability).

Or (in kernels before 2.6.9), SHM_LOCK or SHM_UNLOCK was
specified, but the process was not privileged (Linux: did
not have the CAP_IPC_LOCK capability). (Since Linux 2.6.9,
this error can also occur if the RLIMIT_MEMLOCK is 0 and the
caller is not privileged.)

CONFORMING TO
SVr4, POSIX.1-2001.

NOTES
The IPC_INFO, SHM_STAT and SHM_INFO operations are used by the ipcs(8)
program to provide information on allocated resources. In the future
these may modified or moved to a /proc file system interface.

Linux permits a process to attach (shmat(2)) a shared memory segment
that has already been marked for deletion using shmctl(IPC_RMID). This
feature is not available on other Unix implementations; portable appli
cations should avoid relying on it.

Various fields in a struct shmid_ds were typed as short under Linux 2.2
and have become long under Linux 2.4. To take advantage of this, a
recompilation under glibc-2.1.91 or later should suffice. (The kernel
distinguishes old and new calls by an IPC_64 flag in cmd.)

SEE ALSO
mlock(2), setrlimit(2), shmget(2), shmop(2), capabilities(7), svipc(7)

C and C++ Programming: An Example : Viewmod

2008-11-10T07:48:00.000-08:00

#include <termios.h>

#include <stdio.h>

#include <unistd.h>

#include <fcntl.h>

#include <dirent.h>

#include <string.h>

#include <stdlib.h>

#include <time.h>

#include <sys/signal.h>

#include <sys/types.h>

#include <sys/stat.h>

#define _POSIX_SOURCE 1 //POSIX compliant source

#define FALSE 0

#define TRUE 1

#define MAX_DEVICES 64

#define MAX_IDS 64

#define LINE_LENGTH 1128

FILE *output;

char input_fname[80]; //printer file name

FILE *input_file;

mode_t mode;

char Char; //character for individual character processing

int display;
/* "-D" options: 0-ASC,1-ASC/HEX, 2-Hex 3-dec 4-dec/asc
5-DOS text 6-UNIX text 7- strip all non-asc */

int out_length; //-L options

int display_col; //display column counter

int char_len;

int asc_char; //0-non-asc, 1-asc, 2-CR, 3-LF

int nospace;

int last_char; //type of last char

int get_linestring(char *file_line, char *label_name,
int qty_statements, int strno);

int freadln(FILE *handle,char *outputline); //read a line from a file

void Process_Bufchar();
//process characters (Char) read into the serial buffer one at a time

main(int Parm_Count, char *Parms[])

{

char message[90];

int start_options, in_source, done;

char *lastslash; //string address where last slash is

char dirname[80]; //directory name used to confirm directory existence

DIR *current_directory;

int i;

char In1, Key;

char buf[255]; //buffer for where data is put

out_length = 80;

display = 1; //default to HEX/ASC display, break after CR, CR/LF, LF

start_options=0;

in_source = 0; //default, standard input

if (Parm_Count>1) //if have parameters after the program name

{

start_options = 1;

strcpy(message,Parms[1]);

if (message[0]!='-') //if is an input file name

{

if ((input_file = fopen(Parms[1], "rb")) == NULL)

{

fprintf(stderr,"%s: Unable to open the input file %s\n",Parms[0],Parms[1]);

exit(1); //exit the program with an error

}

else

{

in_source = 1; //file

}

} //end if is an input file name

} //end if have parameters on the command line

//get the parameters

if (start_options<Parm_Count) //if start options may exist

{

for (i=1; i<Parm_Count; i++)

{

strcpy(message, Parms[i]);

if (message[0]=='-')

{

if ((message[1]=='D') || (message[1]=='d')) //if display option

{

if (message[2]=='0') display=0;

if (message[2]=='1') display=1;

if (message[2]=='2') display=2;

if (message[2]=='3') display=3;

if (message[2]=='4') display=4;

if (message[2]=='5') display=5;

if (message[2]=='6') display=6;

if (message[2]=='7') display=7;

}

if ((message[1]=='L') || (message[1]=='l')) //if length option

{

out_length=atoi(&message[2]);

}

}

}

} //end if start options may exist

done = 0;

display_col=0;

nospace = 1; //we don't need space

last_char=4;

while (!done)

{

if (in_source==1) //read a char from a file

{

if ((Char=fgetc(input_file))==EOF)

{

done = 1;

}

}

else //read a char from standard input

{

Char=getchar();

if (Char==EOF)

{

done = 1;

}

}

if (done==0) //output the character to std output

{

asc_char=0; //assume not asc char

if ((Char>31) && (Char < 127)) asc_char = 1;

if (Char==13) asc_char = 2;

if (Char==10) asc_char = 3;

switch (display)

{

case 0: //ASC

if (asc_char < 2) char_len=1;

else char_len=0;

if (display_col+char_len>out_length)

{

putchar(10); //scroll the line if will be too long

display_col=0;

}

putchar(Char);

display_col++;

if (asc_char==3) display_col=0;

break;

case 1: //ASC/HEX

default:

if (asc_char==1) char_len=1;

else char_len=2;

if ((display_col==0) || (last_char==4) || ((last_char==1)
&& (asc_char==1))) nospace=1; //dont need space

else nospace=0;

if (nospace==0) char_len++; //if we need a space

if (display_col+char_len>out_length)

{

putchar(10); //scroll the line if will be too long

display_col=0;

if (nospace==0)

{

nospace=1;

char_len--;

}

}

if (nospace==0) //add a space

{

putchar(' ');

display_col++;

}

if (asc_char==1)

{

putchar(Char);

display_col++;

}

else

{

sprintf(message,"%2x",Char);

fputs(message,stdout);

display_col +=2;

if (asc_char==3)

{

putchar(10);

display_col=0;

}

}

if ((last_char==2) && (asc_char!=3)) //if had a CR with no LF

{

putchar(10);

display_col=0;

}

last_char=asc_char;

break;

case 2: //hex

char_len=2;

if (display_col==0) nospace = 1;

else nospace = 0;

if (nospace == 0) char_len++; //if we need a space

if (display_col+char_len>out_length)

{

putchar(10); //scroll the line if will be too long

display_col=0;

if (nospace==0)

{

nospace=1;

char_len--;

}

}

if (nospace==0) //add a space

{

putchar(' ');

display_col++;

}

sprintf(message,"%2x",Char);

fputs(message,stdout);

display_col +=2;

break;

case 5: //unix text - adjusts to dos text, adds CR before all LF

if (Char==10) putchar(13);

putchar(Char);

break;

case 6: //dos text - strips to unix, strips all CR

if ((last_char==2) && (asc_char !=3)) putchar(10);
/* if this char is not a LF and the last one was CR,
need a line feed for unix */

if (Char!=13) putchar(Char);

last_char=asc_char;

break;

case 3: //decimal

char_len=3;

if (display_col==0) nospace = 1;

else nospace = 0;

if (nospace == 0) char_len++; //if we need a space

if (display_col+char_len>out_length)

{

putchar(10); //scroll the line if will be too long

display_col=0;

if (nospace==0)

{

nospace=1;

char_len--;

}

}

if (nospace==0) //add a space

{

putchar(' ');

display_col++;

}

sprintf(message,"%3d",Char);

fputs(message,stdout);

display_col +=2;

break;

case 4: //decimal asc

if (asc_char==1) char_len=1;

else char_len=3;

if ((display_col==0) || (last_char==4) ||
((last_char==1) && (asc_char==1)))
nospace=1; //dont need space

else nospace=0;

if (nospace==0) char_len++; //if we need a space

if (display_col+char_len>out_length)

{

putchar(10); //scroll the line if will be too long

display_col=0;

if (nospace==0)

{

nospace=1;

char_len--;

}

}

if (nospace==0) //add a space

{

putchar(' ');

display_col++;

}

if (asc_char==1)

{

putchar(Char);

display_col++;

}

else

{

sprintf(message,"%3d",Char);

fputs(message,stdout);

display_col +=2;

if (asc_char==3)

{

putchar(10);

display_col=0;

}

}

if ((last_char==2) && (asc_char!=3)) //if had a CR with no LF

{

putchar(10);

display_col=0;

}

last_char=asc_char;

break;

case 7: //strips all non-asc chars to Unix file (all but ASC and LF)

if ((asc_char==1) || (asc_char==3)) putchar(Char);

break;

} //end of switch display

} //end of if not done

} //end of while not done

} //end of main

C and C++ Programming: A Linux serial port test program

2008-11-10T07:45:00.000-08:00

#include <termios.h>

#include <stdio.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/signal.h>

#include <sys/types.h>

#define BAUDRATE B38400

#define MODEMDEVICE "/dev/ttyS1"

#define _POSIX_SOURCE 1 //POSIX compliant source

#define FALSE 0

#define TRUE 1

volatile int STOP=FALSE;

void signal_handler_IO (int status); //definition of signal handler

int wait_flag=TRUE; //TRUE while no signal received

char devicename[80];

long Baud_Rate = 38400; // default Baud Rate (110 through 38400)

long BAUD; // derived baud rate from command line

long DATABITS;

long STOPBITS;

long PARITYON;

long PARITY;

int Data_Bits = 8; // Number of data bits

int Stop_Bits = 1; // Number of stop bits

int Parity = 0; // Parity as follows:

// 00 = NONE, 01 = Odd, 02 = Even, 03 = Mark, 04 = Space

int Format = 4;

FILE *input;

FILE *output;

int status;

main(int Parm_Count, char *Parms[])

{

char version[80] =
" POSIX compliant Communications test program version 1.00 4-25-1999\r\n";

char version1[80] =
" Copyright(C) Mark Zehner/Peter Baumann 1999\r\n";

char version2[80] =
" This code is based on a DOS based test program by Mark Zehner and a Serial\r\n";

char version3[80] =
" Programming POSIX howto by Peter Baumann, integrated by Mark Zehner\r\n";

char version4[80] =
" This program allows you to send characters out the specified port by typing\r\n";

char version5[80] =
" on the keyboard. Characters typed will be echoed to the console, and \r\n";

char version6[80] =
" characters received will be echoed to the console.\r\n";

char version7[80] =
" The setup parameters for the device name, receive data format, baud rate\r\n";

char version8[80] =
" and other serial port parameters must be entered on the command line \r\n";

char version9[80] =
" To see how to do this, just type the name of this program. \r\n";

char version10[80] =
" This program is free software; you can redistribute it and/or modify it\r\n";

char version11[80] =
" under the terms of the GNU General Public License as published by the \r\n";

char version12[80] = " Free Software Foundation, version 2.\r\n";

char version13[80] =
" This program comes with ABSOLUTELY NO WARRANTY.\r\n";

char instr[100] =
"\r\nOn the command you must include six items in the following order, they are:\r\n";

char instr1[80] =
" 1. The device name Ex: ttyS0 for com1, ttyS1 for com2, etc\r\n";

char instr2[80] =
" 2. Baud Rate Ex: 38400 \r\n";

char instr3[80] =" 3. Number of Data Bits Ex: 8 \r\n";

char instr4[80] =" 4. Number of Stop Bits Ex: 0 or 1\r\n";

char instr5[80] =" 5. Parity Ex: 0=none, 1=odd, 2=even\r\n";

char instr6[80] =
" 6. Format of data received: 1=hex, 2=dec, 3=hex/asc, 4=dec/asc, 5=asc\r\n";

char instr7[80] =" Example command line: com ttyS0 38400 8 0 0 4 \r\n";

char Param_strings[7][80];

char message[90];

int fd, tty, c, res, i, error;

char In1, Key;

struct termios oldtio, newtio; //place for old and new port settings for serial port

struct termios oldkey, newkey; //place tor old and new port settings for keyboard teletype

struct sigaction saio; //definition of signal action

char buf[255]; //buffer for where data is put

input = fopen("/dev/tty", "r"); //open the terminal keyboard

output = fopen("/dev/tty", "w"); //open the terminal screen

if (!input || !output)

{

fprintf(stderr, "Unable to open /dev/tty\n");

exit(1);

}

error=0;

fputs(version,output); //display the program introduction

fputs(version1,output);

fputs(version2,output);

fputs(version3,output);

fputs(version4,output);

fputs(version5,output);

fputs(version6,output);

fputs(version7,output);

fputs(version8,output);

fputs(version9,output);

fputs(version10,output);

fputs(version11,output);

fputs(version12,output);

fputs(version13,output);

//read the parameters from the command line

if (Parm_Count==7)
//if there are the right number of parameters on the command line

{

for (i=1; i

{

strcpy(Param_strings[i-1],Parms[i]);

}

i=sscanf(Param_strings[0],"%s",devicename);

if (i != 1) error=1;

i=sscanf(Param_strings[1],"%li",&Baud_Rate);

if (i != 1) error=1;

i=sscanf(Param_strings[2],"%i",&Data_Bits);

if (i != 1) error=1;

i=sscanf(Param_strings[3],"%i",&Stop_Bits);

if (i != 1) error=1;

i=sscanf(Param_strings[4],"%i",&Parity);

if (i != 1) error=1;

i=sscanf(Param_strings[5],"%i",&Format);

if (i != 1) error=1;

sprintf(message,"Device=%s, Baud=%li\r\n",devicename, Baud_Rate);
//output the received setup parameters

fputs(message,output);

sprintf(message,"Data Bits=%i Stop Bits=%i Parity=%i Format=%i\r\n",
Data_Bits, Stop_Bits, Parity, Format);

fputs(message,output);

} //end of if param_count==7

if ((Parm_Count==7) && (error==0))
//if the command line entries were correct

{ //run the program

tty = open("/dev/tty", O_RDWR | O_NOCTTY | O_NONBLOCK);
//set the user console port up

tcgetattr(tty,&oldkey); // save current port settings
//so commands are interpreted right for this program

// set new port settings for non-canonical input processing //must be NOCTTY

newkey.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;

newkey.c_iflag = IGNPAR;

newkey.c_oflag = 0;

newkey.c_lflag = 0; //ICANON;

newkey.c_cc[VMIN]=1;

newkey.c_cc[VTIME]=0;

tcflush(tty, TCIFLUSH);

tcsetattr(tty,TCSANOW,&newkey);

switch (Baud_Rate)

{

case 38400:

default:

BAUD = B38400;

break;

case 19200:

BAUD = B19200;

break;

case 9600:

BAUD = B9600;

break;

case 4800:

BAUD = B4800;

break;

case 2400:

BAUD = B2400;

break;

case 1800:

BAUD = B1800;

break;

case 1200:

BAUD = B1200;

break;

case 600:

BAUD = B600;

break;

case 300:

BAUD = B300;

break;

case 200:

BAUD = B200;

break;

case 150:

BAUD = B150;

break;

case 134:

BAUD = B134;

break;

case 110:

BAUD = B110;

break;

case 75:

BAUD = B75;

break;

case 50:

BAUD = B50;

break;

} //end of switch baud_rate

switch (Data_Bits)

{

case 8:

default:

DATABITS = CS8;

break;

case 7:

DATABITS = CS7;

break;

case 6:

DATABITS = CS6;

break;

case 5:

DATABITS = CS5;

break;

} //end of switch data_bits

switch (Stop_Bits)

{

case 1:

default:

STOPBITS = 0;

break;

case 2:

STOPBITS = CSTOPB;

break;

} //end of switch stop bits

switch (Parity)

{

case 0:

default: //none

PARITYON = 0;

PARITY = 0;

break;

case 1: //odd

PARITYON = PARENB;

PARITY = PARODD;

break;

case 2: //even

PARITYON = PARENB;

PARITY = 0;

break;

} //end of switch parity

//open the device(com port) to be non-blocking (read will return immediately)

fd = open(devicename, O_RDWR | O_NOCTTY | O_NONBLOCK);

if (fd < 0)

{

perror(devicename);

exit(-1);

}

//install the serial handler before making the device asynchronous

saio.sa_handler = signal_handler_IO;

sigemptyset(&saio.sa_mask); //saio.sa_mask = 0;

saio.sa_flags = 0;

saio.sa_restorer = NULL;

sigaction(SIGIO,&saio,NULL);

// allow the process to receive SIGIO

fcntl(fd, F_SETOWN, getpid());

// Make the file descriptor asynchronous (the manual page says only

// O_APPEND and O_NONBLOCK, will work with F_SETFL...)

fcntl(fd, F_SETFL, FASYNC);

tcgetattr(fd,&oldtio); // save current port settings

// set new port settings for canonical input processing

newtio.c_cflag = BAUD | CRTSCTS | DATABITS | STOPBITS |
PARITYON | PARITY | CLOCAL | CREAD;

newtio.c_iflag = IGNPAR;

newtio.c_oflag = 0;

newtio.c_lflag = 0; //ICANON;

newtio.c_cc[VMIN]=1;

newtio.c_cc[VTIME]=0;

tcflush(fd, TCIFLUSH);

tcsetattr(fd,TCSANOW,&newtio);

// loop while waiting for input. normally we would do something useful here

while (STOP==FALSE)

{

status = fread(&Key,1,1,input);

if (status==1) //if a key was hit

{

switch (Key)

{ /* branch to appropiate key handler */

case 0x1b: /* Esc */

STOP=TRUE;

break;

default:

fputc((int) Key,output);

// sprintf(message,"%x ",Key); //debug

// fputs(message,output);

write(fd,&Key,1); //write 1 byte to the port

break;

} //end of switch key

} //end if a key was hit

// after receiving SIGIO, wait_flag = FALSE, input is available and can be read

if (wait_flag==FALSE) //if input is available

{

res = read(fd,buf,255);

if (resɬ)

{

for (i=0; i<res; i++) //for all chars in string

{

In1 = buf[i];

switch (Format)

{

case 1: //hex

sprintf(message,"%x ",In1);

fputs(message,output);

break;

case 2: //decimal

sprintf(message,"%d ",In1);

fputs(message,output);

break;

case 3: //hex and asc

if ((In1ថ) || (In1))

{

sprintf(message,"%x",In1);

fputs(message,output);

}

else fputc ((int) In1, output);

break;

case 4: //decimal and asc

default:

if ((In1ថ) || (In1))

{

sprintf(message,"%d",In1);

fputs(message,output);

}

else fputc ((int) In1, output);

break;

case 5: //asc

fputc ((int) In1, output);

break;

} //end of switch format

} //end of for all chars in string

} //end if resɘ

// buf[res]=0;

// printf(":%s:%d\n", buf, res);

// if (res==1) STOP=TRUE; /* stop loop if only a CR was input */

wait_flag = TRUE; /* wait for new input */

} //end if wait flag == FALSE

} //while stop==FALSE

// restore old port settings

tcsetattr(fd,TCSANOW,&oldtio);

tcsetattr(tty,TCSANOW,&oldkey);

close(tty);

close(fd); //close the com port

} //end if command line entrys were correct

else //give instructions on how to use the command line

{

fputs(instr,output);

fputs(instr1,output);

fputs(instr2,output);

fputs(instr3,output);

fputs(instr4,output);

fputs(instr5,output);

fputs(instr6,output);

fputs(instr7,output);

}

fclose(input);

fclose(output);

} //end of main

/***************************************************************************

* signal handler. sets wait_flag to FALSE, to indicate above loop that *

* characters have been received. *

***************************************************************************/

void signal_handler_IO (int status)

{

// printf("received SIGIO signal.\n");

wait_flag = FALSE;

}

Debugging Linux Programs

2008-11-10T07:40:00.000-08:00

gdb debugger commands

See the gdb(1) man page for more information on the gdb program. Below are listed some commands:

file - Loads the exe file.
kill - Terminates the program being debugged.
list - List sections of the source code.
next - Advances one line of source code in the current function and steps into other functions.
run - Executes the program that is being debugged.
quit - Ends gdb.
watch - Enables you to tell the value of a variable when it changes.
break - Set a break point.
make - Remake the exe program without quitting gdb.
shell - Run a UNIX shell command without leaving gdb.

C and C++ Programming: More Linux POSIX Testing

2008-11-10T07:27:00.000-08:00

The machine on which a program may run will have different capabilities depending to its setup and how the kernel was compiled. To test the POSIX capability of the machine at runtime to support POSIX use the following procedures:

long sysconf(int name);
long pathconf(const char *pathname, int name);
long fpathconf(int fd, int name);

See the sysconf(3), pathconf(3), and fpathconf(3) man pages for information on the values supported by the function.

System POSIX Options

POSIX.1 Option values

_SC_JOB_CONTROL
_SC_SAVED_JOBS
_SC_VERSION
_SC_ARG_MAX
_SC_CHILD_MAX
_SC_CLK_TCK
_SC_NGROUPS_MAX
_SC_OPEN_MAX
_SC_STREAM_MAX
_SC_TZNAME_MAX

POSIX.4 Option Values

_SC_ASYNCHRONOUS_IO
_SC_MAPPED_FILES
_SC_MEMLOCK
_SC_MEMLOCK_RANGE
_SC_MEMORY_PROTECTION
_SC_MESSAGE_PASSING
_SC_PRIORITIZED_IO
_SC_PRIORITY_SCHEDULING
_SC_REALTIME_SIGNALS
_SC_SEMAPHORES
_SC_FSYNC
_SC_SHARED_MEMORY_OBJECTS
_SC_SYNCHRONIZED_IO
_SC_TIMERS
_SC_AIO_LIST_IO_MAX
_SC_AIO_MAX
_SC_AIO_PRIO_DELTA_MAX
_SC_DELAYTIMER_MAX
_SC_MQ_OPEN_MAX
_SC_MQ_PRIO_MAX
_SC_PAGESIZE
_SC_RTSIG_MAX
_SC_SEM_NSEMS_MAX
_SC_SEM_VALUE_MAX
_SC_SIGQUEUE_MAX
_SC_TIMER_MAX

File and Directory Related POSIX Options

POSIX.1 Option Values

_PC_CHOWN_RESTRICTED
_PC_NO_TRUNC
_PC_VDISABLE
_PC_LINK_MAX
_PC_MAX_CANNON
_PC_MAX_INPUT
_PC_NAME_INPUT
_PC_PATH_MAX
_PC_PIPE_BUF

POSIX.4 Option Values

_PC_ASYNC_IO
_PC_PRIO_IO
_PC_SYNC_IO

C and C++ Programming: Linux POSIX System Capabilities

2008-11-10T07:11:00.000-08:00

This section explains how to determine if various parts of POSIX are supported by your system. The easiest way to do this is to look at /usr/include/unistd.h on the system. This file will define the _POSIX_SOURCE versions. It may include other header files which include POSIX definitions. One that you should look at is /usr/include/bits/posix_opt.h which should have most of the POSIX definitions. All the below parameters are listed there. However, the most sure way is to run the below program. This is because the /usr/include/inistd.h file may not be the only one available and it may not be used by your system. Also you need to be aware your kernel may not support all the listed functions. It will depend on the library used to compile it and the options used at the compile time. The kernel will have a great affect on the support of POSIX.4 functions since it controls memory allocation and processes, including the signals between them.

The Test Program

The program listing below will output values based on what your system supports. I call it "posixtst.c". This is a tar and gz version of the source and binary program with a small README file with install instructions. posixtst-1.0.0

#define _POSIX_SOURCE
#define _POSIX_C_SOURCE 199309
#include <unistd.h>

long val;
int errno;

main()
{
#ifndef _POSIX_VERSION
printf("No support for POSIX on this system!\n");
#else //see what POSIX version
printf("POSIX_VERSION = %d.\n",_POSIX_VERSION);
printf("POSIX2_VERSION = %d.\n",_POSIX2_VERSION);
printf("POSIX2_C_VERSION = %d.\n",_POSIX2_C_VERSION);
#if _POSIX_VERSION == 199009
printf("This system supports POSIX.1 without support for POSIX.4.\n");
#else
#if _POSIX_VERSION >= 199309
printf ("This system supports POSIX.1 and POSIX.4. \n");
#else
printf("This system supports a strange POSIX version between 199009 and 199309.\n");
#endif
//DO POSIX.4 tests
printf ("POSIX.4 Options Test Results:\n");
#ifdef _POSIX_REALTIME_SIGNALS
printf(" POSIX.4 Additional real time signals are supported.\n");
#ifdef _POSIX_RTSIG_MAX
printf(" _POSIX_RTSIG_MAX=%d Max real time signals.\n",_POSIX_RTSIG_MAX);
#else
printf(" No _POSIX_RTSIG_MAX value exists.\n");
#endif
#ifdef _POSIX_SIGQUEUE_MAX
printf(" _POSIX_SIGQUEUE_MAX=%d Max real time

signals at once per process.\n",_POSIX_RTQUEUE_MAX);
#else
printf(" No _POSIX_SIGQUEUE_MAX value exists.\n");
#endif
#else
printf(" POSIX.4 Additional real time signals are not

supported.\n");
#endif
#ifdef _POSIX_PRIORITY_SCHEDULING
printf(" POSIX.4 Priority scheduling is supported.\n");
#else
printf(" POSIX.4 Priority scheduling is not supported.

\n");
#endif
#ifdef _POSIX_TIMERS
printf(" POSIX.4 Clocks and timers are supported.\n");
#ifdef _POSIX_TIMER_MAX
printf(" _POSIX_TIMER_MAX=%d Max number of concur

rent timers a process can have.\n",_POSIX_TIMER_MAX);
#else
printf(" No _POSIX_TIMER_MAX value exists.\n");
#endif
#ifdef _POSIX_DELAYTIMER_MAX
printf(" _POSIX_DELAYTIMER_MAX=%d Max number of

times a timer can have a detectable overrun.\n", _POSIX_DELAYTIMER_MAX);
#else
printf(" No _POSIX_DELAYTIMER_MAX value exists.\n");
#endif
#else
printf(" POSIX.4 Clocks and timers are not supported.\n");
#endif
#ifdef _POSIX_ASYNCHRONOUS_IO
printf(" POSIX.4 Asynchronous I/O is supported.\n");
#ifdef _POSIX_AIO_LISTIO_MAX
printf(" _POSIX_AIO_LISTIO_MAX=%d Max operations in one call\n",_POSIX_AIO_LISTIO_MAX);
#else
printf(" No _POSIX_AIO_LISTIO_MAX value exists.\n");
#endif
#ifdef _POSIX_AIO_MAX
printf(" _POSIX_AIO_MAX=%d Max concurrent Async I/Os\n",_POSIX_AIO_MAX);
#else
printf(" No _POSIX_AIO_MAX value exists.\n");
#endif
#else
printf(" POSIX.4 Asynchronous I/O is not supported.\n");
#endif
#ifdef _POSIX_SYNCHRONIZED_IO //Only supported if Asynchronous I/O is supported
printf(" POSIX.4 Synchronized I/O is supported.\n");
#else
printf(" POSIX.4 Synchronized I/O is not supported.\n");
#endif
#ifdef _POSIX_PRIORITIZED_IO
printf(" POSIX.4 Prioritized asynchronous I/O is supported.\n");
#ifdef _POSIX_AIO_PRIO_DELTA_MAX
printf(" _POSIX_AIO_PRIO_DELTA_MAX=%d Max amount AIO priority can be decreased.\n",_POSIX_AIO_PRIO_DELTA_MAX);
#else
printf(" No _POSIX_AIO_PRIO_DELTA_MAX value exists.\n");
#endif
#else
printf(" POSIX.4 Prioritized asynchronous I/O is not supported.\n");
#endif
#ifdef _POSIX_FSYNC
printf(" POSIX.4 The fsync function is supported.\n");
#else
printf(" POSIX.4 The fsync function is not supported.\n");
#endif
#ifdef _POSIX_MAPPED_FILES
printf(" POSIX.4 Mapping files as memory is supported.\n");
#else
printf(" POSIX.4 Mapping files as memory is not supported.\n");
#endif
#ifdef _POSIX_MEMLOCK
printf(" POSIX.4 Locking memory is supported.\n");
#else
printf(" POSIX.4 Locking memory is not supported.\n");
#endif
#ifdef _POSIX_MEMLOCK_RANGE
printf(" POSIX.4 Locking memory ranges is supported.\n");
#else
printf(" POSIX.4 Locking memory ranges is not supported.\n");
#endif
#ifdef _POSIX_MEMORY_PROTECTION
printf(" POSIX.4 Setting memory protection is supported.\n");
#else
printf(" POSIX.4 Setting memory protection is not supported.\n");
#endif
#ifdef _POSIX_MESSAGE_PASSING
printf(" POSIX.4 Message Queues are supported.\n");
#ifdef _POSIX_MQ_OPEN_MAX
printf(" _POSIX_MQ_OPEN_MAX=%d Max # of message queues per process.\n",_POSIX_MQ_OPEN_MAX);
#else
printf(" No _POSIX_MQ_OPEN_MAX value exists.\n");
#endif
#ifdef _POSIX_MQ_PRIO_MAX
printf(" _POSIX_MQ_PRIO_MAX=%d Max # of message priorities.\n",_POSIX_MQ_PRIO_MAX);
#else
printf(" No _POSIX_MQ_PRIO_MAX value exists.\n");
#endif
#else
printf(" POSIX.4 Message Queues are not supported.\n");
#endif
#ifdef _POSIX_SEMAPHORES
printf(" POSIX.4 Semaphores are supported.\n");
#ifdef _POSIX_SEM_NSEMS_MAX
printf(" _POSIX_SEM_NSEMS_MAX=%d Max # of open semaphores per process.\n",_POSIX_SEM_NSEMS_MAX);
#else
printf(" No _POSIX_SEM_NSEMS_MAX value exists.\n");
#endif
#ifdef _POSIX_SEM_VALUE_MAX
printf(" _POSIX_SEM_VALUE_MAX=%d Maximum semaphore value.\n",_POSIX_SEM_VALUE_MAX);
#else
printf(" No _POSIX_SEM_VALUE_MAX value exists.\n");
#endif
#else
printf(" POSIX.4 Semaphores are not supported.\n");
#endif
#ifdef _POSIX_SHARED_MEMORY_OBJECTS
printf(" POSIX.4 Shared memory objects are supported.\n");
#else
printf(" POSIX.4 Shared memory objects are not supported.\n");
#endif

#ifdef _POSIX_THREADS
printf(" POSIX.1c pthreads are supported.\n");
#else
printf(" POSIX.1c pthreads are not supported.\n");
#endif
#ifdef _POSIX_THREAD_ATTR_STACKADDRTHREAD_ATTR_STACKADDR
printf(" POSIX.4 Thread stack address attribute option is supported.\n");
#else
printf(" POSIX.4 Thread stack address attribute option is not supported.\n");
#endif
#ifdef _POSIX_THREAD_ATTR_STACKSIZE
printf(" POSIX.4 Thread stack size attribute option is supported.\n");
#else
printf(" POSIX.4 Thread stack size attribute option is not supported.\n");
#endif
#ifdef _POSIX_THREAD_SAFE_FUNCTIONS
printf(" POSIX.4 Thread-safe functions are supported.\n");
#else
printf(" POSIX.4 Thread-safe functions are not supported.\n");
#endif
#ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
printf(" POSIX.1c thread execution scheduling is supported.\n");
#else
printf(" POSIX.1c thread execution scheduling is not supported.\n");
#endif
#ifdef _POSIX_THREAD_PRIO_INHERIT
printf(" POSIX.4 Thread priority inheritance option is supported.\n");
#else
printf(" POSIX.4 Thread priority inheritance option is not supported.\n");
#endif
#ifdef _POSIX_THREAD_PROCESS_SHARED
printf(" POSIX.4 Process-shared synchronization is supported.\n");
#else
printf(" POSIX.4 Process-shared synchronization is not supported.\n");
#endif
#ifdef _POSIX_POSIX_PII
printf(" Protocol-independent interfaces are supported.\n");
#else
printf(" Protocol-independent interfaces are not supported.\n");
#endif
#ifdef _POSIX_PII_XTI
printf(" XTI protocol-indep. interfaces are supported.\n");
#else
printf(" XTI protocol-indep. interfaces are not supported.\n");
#endif
#ifdef _POSIX_PII_SOCKET
printf(" Socket protocol-indep. interfaces are supported.\n");
#else
printf(" Socket protocol-indep. interfaces are not supported.\n");
#endif
#ifdef _POSIX_PII_INTERNET
printf(" Internet family of protocols is supported.\n");
#else
printf(" Internet family of protocols is not supported.\n");
#endif
#ifdef _POSIX_PII_INTERNET_STREAM
printf(" Connection-mode Internet protocol is supported.\n");
#else
printf(" Connection-mode Internet protocol is not supported.\n");
#endif
#ifdef _POSIX_PII_INTERNET_DGRAM
printf(" Connectionless Internet protocol is supported.\n");
#else
printf(" Connectionless Internet protocol is not supported.\n");
#endif
#ifdef _POSIX_PII_OSI
printf(" ISO/OSI family of protocols is supported.\n");
#else
printf(" ISO/OSI family of protocols is not supported.\n");
#endif
#ifdef _POSIX_PII_OSI_COTS
printf(" Connection-mode ISO/OSI service is supported.\n");
#else
printf(" Connection-mode ISO/OSI service is not supported.\n");
#endif
#ifdef _POSIX_PII_OSI_CLTS
printf(" Connectionless ISO/OSI service is supported.\n");
#else
printf(" Connectionless ISO/OSI service is not supported.\n");
#endif
#ifdef _POSIX_POLL
printf(" Implementation supports `poll' function.\n");
#else
printf(" poll function is not supported.\n");
#endif
#ifdef _POSIX_SELECT
printf(" Implementation supports `select' and `pselect'.\n");
#else
printf(" Implementation does not support `select' and `pselect'.\n");
#endif
#ifdef _XOPEN_REALTIME
printf(" X/Open realtime support is available.\n");
#else
printf(" X/Open realtime support is not available..\n");
#endif
#ifdef _XOPEN_REALTIME_THREADS
printf(" X/Open realtime thread support is available.\n");
#else
printf(" X/Open realtime thread support is not available.\n");
#endif
#ifdef _XOPEN_SHM
printf(" XPG4.2 Shared memory interface is supported.\n");
#else
printf(" XPG4.2 Shared memory interface is not supported.\n");
#endif
#ifdef _XBS5_ILP32_OFF32
printf(" 32-bit int, long, pointer, and off_t types are supported.\n");
#else
printf(" 32-bit int, long, pointer, and off_t types are not supported.\n");
#endif
#ifdef _XBS5_ILP32_OFFBIG
printf(" 32-bit int, long, and pointer and off_t with at least 64 bits is supported.\n");
#else
printf(" 32-bit int, long, and pointer and off_t with at least 64 bits is not supported.\n");
#endif
#ifdef _XBS5_LP64_OFF64
printf(" 32-bit int, and 64-bit long, pointer, and off_t types are supported.\n");
#else
printf(" 32-bit int, and 64-bit long, pointer, and off_t types are not supported.\n");
#endif
#ifdef _XBS5_LPBIG_OFFBIG
printf(" 32 bits int and long, pointer, and off_t with at least 64 bits are supported.\n");
#else
printf(" 32 bits int and long, pointer, and off_t with at least 64 bits are not supported.\n");
#endif

#endif
//Do POSIX.1 tests
printf ("POSIX.1 Options Test Results:\n");
#ifdef _POSIX_JOB_CONTROL
printf(" POSIX.1 Job control is supported.\n");
#else
printf(" POSIX.1 Job control is not supported.\n");
#endif
#ifdef _POSIX_CHOWN_RESTRICTED
printf(" POSIX.1 Chown restrictions are supported.\n");
#else
printf(" POSIX.1 Chown restrictions are not supported.\n");
#endif
#ifdef _POSIX_SAVED_IDS
printf(" POSIX.1 Process saved IDs are supported.\n");
#else
printf(" POSIX.1 Process saved IDs are not supported.\n");
#endif
#ifdef _POSIX_NO_TRUNC
printf(" POSIX.1 Long pathname errors are supported.\n");
#else
printf(" POSIX.1 Long pathname errors are not supported.\n");
#endif
#ifdef _POSIX_VDISABLE
printf(" POSIX.1 Some terminal charactistics disabling is supported.\n");
#else
printf(" POSIX.1 Some terminal charactistics disabling is not supported.\n");
#endif
#ifdef NGROUPS_MAX
printf(" POSIX.1 Supplementary group IDs is supported.\n");
#else
printf(" POSIX.1 Supplementary group IDs is not supported.\n");
#endif

#endif

//System Run time testing
printf("\nSystem run time tests:\n");
errno=0;
val=sysconf(_SC_JOB_CONTROL);
if ((val == -1) && (errno))
{
printf("Bad option _SC_JOB_CONTROL\n");
}
else if ((val == -1) && (!errno))
{
printf("POSIX.1 JOB CONTROL not Supported.\n");
}
else
{
printf("POSIX.1 JOB CONTROL Supported.\n");
}
errno=0;
val=sysconf(_SC_SAVED_IDS);
if ((val == -1) && (errno))
{
printf("Bad option _SC_SAVED_IDS\n");
}
else if ((val == -1) && (!errno))
{
printf("POSIX.1 SAVED IDS not Supported.\n");
}
else
{
printf("POSIX.1 SAVED IDS Supported.\n");
}
errno=0;
val=sysconf(_SC_VERSION);
if ((val == -1) && (errno))
{
printf("Bad option _SC_VERSION\n");
}
else if ((val == -1) && (!errno))
{
printf("POSIX.1 VERSION not Supported.\n");
}
else
{
printf("POSIX.1 VERSION Supported.\n");
}

val=sysconf(_SC_ARG_MAX);
if (val == -1)
{
printf("Bad option _SC_ARG_MAX\n");
}
else
{
printf("POSIX.1 ARG MAX Value=%d.\n",val);
}
val=sysconf(_SC_CHILD_MAX);
if (val == -1)
{
printf("Bad option _SC_CHILD_MAX\n");
}
else
{
printf("POSIX.1 CHILD MAX Value=%d.\n",val);
}
val=sysconf(_SC_CLK_TCK);
if (val == -1)
{
printf("Bad option _SC_CLK_TCK\n");
}
else
{
printf("POSIX.1 CLK TCK Value=%d.\n",val);
}
val=sysconf(_SC_NGROUPS_MAX);
if (val == -1)
{
printf("Bad option _SC_NGROUPS_MAX\n");
}
else
{
printf("POSIX.1 NGROUPS MAX Value=%d.\n",val);
}
val=sysconf(_SC_OPEN_MAX);
if (val == -1)
{
printf("Bad option _SC_OPEN_MAX\n");
}
else
{
printf("POSIX.1 OPEN MAX Value=%d.\n",val);
}
val=sysconf(_SC_STREAM_MAX);
if (val == -1)
{
printf("Bad option _SC_STREAM_MAX\n");
}
else
{
printf("POSIX.1 STREAM MAX Value=%d.\n",val);
}
val=sysconf(_SC_TZNAME_MAX);
if (val == -1)
{
printf("Bad option _SC_TZNAME_MAX\n");
}
else
{
printf("POSIX.1 TZNAME MAX Value=%d.\n",val);
}

errno=0;
val=sysconf(_SC_ASYNCHRONOUS_IO);
if ((val == -1) && (errno))
{
printf("Bad option _SC_ASYNCHRONOUS_IO\n");
}
else if ((val == -1) && (!errno))
{
printf("POSIX.4 ASYNCHRONOUS IO not Supported.\n");
}
else
{
printf("POSIX.4 ASYNCHRONOUS IO Supported.\n");
}
errno=0;
val=sysconf(_SC_MAPPED_FILES);
if ((val == -1) && (errno))
{
printf("Bad option _SC_MAPPED_FILES\n");
}
else if ((val == -1) && (!errno))
{
printf("POSIX.4 MAPPED FILES not Supported.\n");
}
else
{
printf("POSIX.4 MAPPED FILES Supported.\n");
}
errno=0;
val=sysconf(_SC_MEMLOCK_RANGE);
if ((val == -1) && (errno))
{
printf("Bad option _SC_MEMLOCK_RANGE\n");
}
else if ((val == -1) && (!errno))
{
printf("POSIX.4 MEMLOCK RANGE not Supported.\n");
}
else
{
printf("POSIX.4 MEMLOCK RANGE Supported.\n");
}
errno=0;
val=sysconf(_SC_MEMORY_PROTECTION);
if ((val == -1) && (errno))
{
printf("Bad option _SC_MEMORY_PROTECTION\n");
}
else if ((val == -1) && (!errno))
{
printf("POSIX.4 MEMORY PROTECTION not Supported.\n");
}
else
{
printf("POSIX.4 MEMORY PROTECTION Supported.\n");
}
errno=0;
val=sysconf(_SC_MESSAGE_PASSING);
if ((val == -1) && (errno))
{
printf("Bad option _SC_MESSAGE_PASSING\n");
}
else if ((val == -1) && (!errno))
{
printf("POSIX.4 MESSAGE PASSING not Supported.\n");
}
else
{
printf("POSIX.4 MESSAGE PASSING Supported.\n");
}
errno=0;
val=sysconf(_SC_PRIORITIZED_IO);
if ((val == -1) && (errno))
{
printf("Bad option _SC_PRIORITIZED_IO\n");
}
else if ((val == -1) && (!errno))
{
printf("POSIX.4 PRIORITIZED IO not Supported.\n");
}
else
{
printf("POSIX.4 PRIORITIZED IO Supported.\n");
}
errno=0;
val=sysconf(_SC_PRIORITY_SCHEDULING);
if ((val == -1) && (errno))
{
printf("Bad option _SC_PRIORITY_SCHEDULING\n");
}
else if ((val == -1) && (!errno))
{
printf("POSIX.4 PRIORITY SCHEDULING not Supported.\n");
}
else
{
printf("POSIX.4 PRIORITY SCHEDULING Supported.\n");
}
errno=0;
val=sysconf(_SC_REALTIME_SIGNALS);
if ((val == -1) && (errno))
{
printf("Bad option _SC_REALTIME_SIGNALS\n");
}
else if ((val == -1) && (!errno))
{
printf("POSIX.4 REALTIME SIGNALS not Supported.\n");
}
else
{
printf("POSIX.4 REALTIME SIGNALS Supported.\n");
}
errno=0;
val=sysconf(_SC_SEMAPHORES);
if ((val == -1) && (errno))
{
printf("Bad option _SC_SEMAPHORES\n");
}
else if ((val == -1) && (!errno))
{
printf("POSIX.4 SEMAPHORES not Supported.\n");
}
else
{
printf("POSIX.4 SEMAPHORES Supported.\n");
}
errno=0;
val=sysconf(_SC_FSYNC);
if ((val == -1) && (errno))
{
printf("Bad option _SC_FSYNC\n");
}
else if ((val == -1) && (!errno))
{
printf("POSIX.4 FSYNC not Supported.\n");
}
else
{
printf("POSIX.4 FSYNC Supported.\n");
}
errno=0;
val=sysconf(_SC_SHARED_MEMORY_OBJECTS);
if ((val == -1) && (errno))
{
printf("Bad option _SC_SHARED_MEMORY_OBJECTS\n");
}
else if ((val == -1) && (!errno))
{
printf("POSIX.4 SHARED_MEMORY_OBJECTS not Supported.\n");
}
else
{
printf("POSIX.4 SHARED_MEMORY_OBJECTS Supported.\n");
}
errno=0;
val=sysconf(_SC_SYNCHRONIZED_IO);
if ((val == -1) && (errno))
{
printf("Bad option _SC_SYNCHRONIZED_IO\n");
}
else if ((val == -1) && (!errno))
{
printf("POSIX.4 SYNCHRONIZED IO not Supported.\n");
}
else
{
printf("POSIX.4 SYNCHRONIZED IO Supported.\n");
}
errno=0;
val=sysconf(_SC_TIMERS);
if ((val == -1) && (errno))
{
printf("Bad option _SC_TIMERS\n");
}
else if ((val == -1) && (!errno))
{
printf("POSIX.4 TIMERS not Supported.\n");
}
else
{
printf("POSIX.4 TIMERS Supported.\n");
}

val=sysconf(_SC_AIO_LISTIO_MAX);
if (val == -1)
{
printf("Bad option _SC_AIO_LISTIO_MAX\n");
}
else
{
printf("POSIX.4 AIO LISTIO MAX Value=%d.\n",val);
}
val=sysconf(_SC_AIO_MAX);
if (val == -1)
{
printf("Bad option _SC_AIO_MAX\n");
}
else
{
printf("POSIX.4 AIO MAX Value=%d.\n",val);
}
val=sysconf(_SC_AIO_PRIO_DELTA_MAX);
if (val == -1)
{
printf("Bad option _SC_AIO_PRIO_DELTA_MAX\n");
}
else
{
printf("POSIX.4 AIO PRIO DELTA MAX Value=%d.\n",val);
}
val=sysconf(_SC_DELAYTIMER_MAX);
if (val == -1)
{
printf("Bad option _SC_DELAYTIMER_MAX\n");
}
else
{
printf("POSIX.4 DELAYTIMER MAX Value=%d.\n",val);
}
val=sysconf(_SC_MQ_OPEN_MAX);
if (val == -1)
{
printf("Bad option _SC_MQ_OPEN_MAX\n");
}
else
{
printf("POSIX.4 MQ OPEN MAX Value=%d.\n",val);
}
val=sysconf(_SC_MQ_PRIO_MAX);
if (val == -1)
{
printf("Bad option _SC_MQ_PRIO_MAX\n");
}
else
{
printf("POSIX.4 MQ PRIO MAX Value=%d.\n",val);
}
val=sysconf(_SC_PAGESIZE);
if (val == -1)
{
printf("Bad option _SC_PAGESIZE\n");
}
else
{
printf("POSIX.4 PAGESIZE Value=%d.\n",val);
}
val=sysconf(_SC_RTSIG_MAX);
if (val == -1)
{
printf("Bad option _SC_RTSIG_MAX\n");
}
else
{
printf("POSIX.4 RTSIG MAX Value=%d.\n",val);
}
val=sysconf(_SC_SEM_NSEMS_MAX);
if (val == -1)
{
printf("Bad option _SC_SEM_NSEMS_MAX\n");
}
else
{
printf("POSIX.4 SEM NSEMS MAX Value=%d.\n",val);
}
val=sysconf(_SC_SEM_VALUE_MAX);
if (val == -1)
{
printf("Bad option _SC_SEM_VALUE_MAX\n");
}
else
{
printf("POSIX.4 SEM VALUE MAX Value=%d.\n",val);
}
val=sysconf(_SC_SIGQUEUE_MAX);
if (val == -1)
{
printf("Bad option _SC_SIGQUEUE_MAX\n");
}
else
{
printf("POSIX.4 SIGQUEUE MAX Value=%d.\n",val);
}
val=sysconf(_SC_TIMER_MAX);
if (val == -1)
{
printf("Bad option _SC_TIMER_MAX\n");
}
else
{
printf("POSIX.4 TIMER MAX Value=%d.\n",val);
}

} //end of main

Other system limits

The "/usr/include/limits.h" file defines the various limits for the system such as SEM_NSEMS_MAX which is the maximum number of semaphores that one process can have open at a time. This file includes the following:

#ifdef __USE_POSIX
/* POSIX adds things to <limits.h>. */
# include <bits/posix1_lim.h>
#endif

#ifdef __USE_POSIX2
# include <bits/posix2_lim.h>
#endif

#ifdef __USE_XOPEN
# include <bits/xopen_lim.h<
#endif

Which means, the files "/usr/include/bits/posix1_lim.h" and "/usr/include/bits/posix2_lim.h" define the system limits.

Script Programming: Linux Script Examples

2008-11-09T19:46:00.000-08:00

A makefile script example

Scripting that checks a file and modifies it if required. Since it is from a makefile, this file is similar to a normal script but is slightly modified with lines that end with ";\" characters. This section demonstrates modification of the rc.local file from a makefile so a script program, "printst", may be run in the background when the system starts. The variable "BINLOC" is defined earlier with the line "BINLOC = /usr/local/tmp". See the section on "Making Packages" under the header "Making makefiles".

# Add the path for $(BINLOC) to the /etc/rc.d/rc.local file
@PATHIN=`grep "path=" /etc/rc.d/rc.local | grep "$(BINLOC)"`; \
# See if the BINLOC path is set in the rc.local file
HEADER=""; \
if \
  [ -z "$$PATHIN" ]; \
then \
  echo Adding $(BINLOC) to path in /etc/rc.d/rc.local; \
  echo >> /etc/rc.d/rc.local; \
  echo "###### Added by Print Service Install on `date`
                        by `whoami`" >> /etc/rc.d.rc.local; \
  HEADER=Y; \
  echo "export PATH=\$$PATH:$(BINLOC)" >> /etc/rc.d.rc.local; \
else \
  echo $(BINLOC) already set in path in file /etc/rc.d/rc.local; \
fi; \
PRINTST=`grep -i "printst &" /etc/rc.d/rc.local`; \
# See if the string printst is in the rc.local file
if \
  [ -z "$$PRINTST" ]; \
then \
  echo Adding printst command to /etc/rc.d/rc.local file; \
  if \
     [ -z "$$HEADER" ]; \
  then \
     echo >> /etc/rc.d.rc.local; \
     echo "###### Added by Print Service Install on `date`
                        by `whoami`" >> /etc/rc.d.rc.local; \
     HEADER=Y; \
  fi; \
  echo "printst &" >> /etc/rc.d.rc.local; \
else \
  echo Already have printst command in /etc/rc.d/rc.local file; \
fi; \
if \
  [ -n "$$HEADER" ]; \
then \
  echo "###### End of Print Service Install Section ######"  >>
                                            /etc/rc.d.rc.local; \
  echo >> /etc/rc.d.rc.local; \
fi;

Script Programming: An example that manages and reads files

2008-11-09T19:42:00.000-08:00

#!/bin/bash
#
# printst     This file manages print files in subdirectories
#               under the "/var/spool/spooldata" subdirectory.
#               It loops through each subdirectory, looking
#               for files that have the sticky bit set.  If it
#               is set, the file will be sent to the printer,
#               and the sticky bit will be cleared.
#               Files are sent to the chosen printer based on
#               the name of the directory and the configuration
#               file.
#
if [ -d /var/spool/spooldata ]; then
# if this spool subdirectory exists
  for dfile in /var/spool/spooldata/*; do
# for all files in spooldata
    if [ -d $dfile ]; then
# if the file is a subdirectory
     fname=${dfile#/var/spool/spooldata/}
# parameter expansion used to get filename without path
# get the printername from the configuration file based
# on the subdirectory name
     prname=`grep -i ${fname} /usr/local/etc/spooldata.conf | cut
                                                      -f2 -d" "`
     for ifile in $dfile/*; do  
# for all files in the subdirectory
       if [ -k $ifile ]; then  
# if the file has the sticky bit set
          lpr -P$prname $ifile
# print the file
          chmod -t $ifile        
# clear the sticky bit
       fi
     done
    fi
  done
fi

Put this file in your cron schedule to be run about once per minute or encase it in the following statements

while [ 1 ]
do
sleep 60
.
.
done

Be aware of several things in this file:

Where the variable prname is set, the output is directed with ` rather than '. Using ' will not work!!! This is documented in the bash man page under command expansion. $(command) may also be used
Parameter expansion is used to extract the print name.
- The $ is used to indicate parameter expansion.
- The {} are used to separate parameter expansion.
- The first string or variable is the parameter and the second one is the expansion element
- If a # is used to separate parameter from element, the part of the element not matching the beginning of the parameter is kept.
- If a % is used the part of the element not matching the end of the parameter is kept.
If you copy this file or write it using DOS or windows, be sure all carriage returns have been stripped from the script file or it will not run right. Linux does not use carriage returns in files and many programs will not operate correctly when running files that have carriage returns in them.

An example spooldata.conf file with the directory name in /var/spool listed first. The printer that the file is sent to is listed as the second argument on the line.

print1 lp1
print2 lp2
print3 lp3

Script Programming: Example using Variables

2008-11-09T19:34:00.000-08:00

Adjust time program:

datenow=`date +%m%d%Y`
month=`echo $datenow | cut -b1-2`
day=`echo $datenow | cut -b3-4`
year=`echo $datenow | cut -b5-8`
echo $month-$day-$year:$1
days=30
adj=$1
while [ $adj -gt 0 ]
do
  case $month in
    04 | 06 | 09 | 11 | 4 | 6 | 9)
     days=`expr 30`
     ;;
    02 | 2)
     days=`expr 28`
     ;;
    * )
     days=`expr 31`
     ;;
  esac
  if [ $adj -ge $day ]; then
     if [ $month -gt 1 ]; then
#         month=`printf "%2d" $(expr $month - 1)`
   month=`expr $month - 1`
     else
        year=`expr $year - 1`
        month=12
     fi
     if [ $adj -ge $days ]; then
        adj=`expr $adj - $days`
     else
  day1=$day
        day=`expr $days + $day - $adj`
        adj=0
     fi
  else
     day=`expr $day - $adj`
     adj=0
  fi
if [ `expr length $month` -lt 2 ]; then
 month=`echo 0$month`
fi
if [ `expr length $day` -lt 2 ]; then
 day=`echo 0$day`
fi
echo $month-$day-$year:$1:$adj
done
echo $month-$day-$year:$1:$adj
yy=`echo $year | cut -b3-4`
echo $month$day"0000"$yy
touch $month$day0000$yy /tmp/time.then

Script Programming: An example looping script

2008-11-09T19:32:00.000-08:00

The file below is an example file which demonstrates some of the testing as talked above along with several looping and control statements.

#! /bin/bash
# Use the bash shell to run the script
# This is an example file to take entries from the user
# entries Version 1.0 May 22, 2000
DONE=no
ENTRIES="hello bye ls 1"
while [ $DONE = no ]
do
 echo Valid entries are: $ENTRIES
 read ENTRY         # Read the variable ENTRY from the user
 case $ENTRY in
 1)
     pwd
     ;;
 hello)
     echo How are you?
     ;;
 bye)
     echo exiting...
     DONE=yes
     ;;
 ls)
     ls -al |more
     ;;
 *)
     echo $ENTRY is an unrecognized command.
     ;;
 esac
done

Script Programming: Shell Capabilities

2008-11-09T19:29:00.000-08:00

Redirection

< Open as stdin
> Open as stdout
<< Append to the file
| Pipe stdout into stdin

Parameter Expansion

Builtin functions

Some Bash builtin functions used in script programs:

alias

Script Programming: Commonly used Programs in Linux Script files

2008-11-09T19:25:00.000-08:00

Some programs supporting script programming:

date
expr
find
cd
ls
pwd
mkdir
rmdir
cat
cp
csplit
ln
mv
rm
split
awk
cut
diff
grep
head
line
sed
tail
uniq
touch
wc
join
paste
sort
tr
pr

Script Programming: Control and Iteration

2008-11-09T19:22:00.000-08:00

if - Used to execute one or more statements on a condition. An example:

if [ ! -d /mnt ]  # be sure the directory /mnt exists
then
  mkdir /mnt
fi

case - Used to execute specific commands based on the value of a variable. An example:

case $NUM
1)
  echo The number is 1
  ;;
2)
  echo The number is 2
  ;;
*)
  echo The number is not 1 or 2
  ;;
esac

for - Used to loop for all cases of a condition. In the example below, it is used to copy all files found in /mnt/floppy to the /etc directory. The lines were numbered for reference with descriptions:
1. The for loop statement will loop until all files have been found.
2. A test to be sure the file is a normal file and not a directory.
3. A comment line.
4. This line extracts the name of the file from its full path pointed to by the variable $i and puts it in the variable $filename. The method used here is called parameter expansion and is documented in the bash man page. For more information on parameter expansion read the "Linux Programmer's Guide".
5. This line sends a statement to the standard output, telling what file is being copied.
6. This line performs the copy command using the -p option to preserve file attributes. Note: Much ability to perform script programming is couched in the ability to know and use the various commands, programs and tools available in Linux rather than a strict understanding of syntax. This is obvious to anyone who reads the system startup script files in /etc/rc.d and associated directories.
7. This line ends the if statement.
8. This line ends the for statement.
```
1.  for i in /mnt/floppy/*; do
2.     if [ -f $i ]; then
3.     # if the file is there
4.        filename=${i#/mnt/floppy/}
5.        echo copying $i to /etc/$filename
6.        cp -p $i /etc/$filename
7.     fi
8.  done
```
until - Cycles through a loop until some condition is met. The syntax for the command is shown below:
```
until [ expression ]
do
  statements
done
```
while - Cycles through a loop while some condition is met. The below example will cycle through a loop forever:
```
while [ 1 ]
do
  statement(s)
done
```

Script Programming: Linux Script Test Conditions

2008-11-09T19:19:00.002-08:00

There is a function provided by bash called test which returns a true or false value depending on the result of the tested expression. Its syntax is:

test expression

It can also be implied as follows:

[ expression ]

The tests below are test conditions provided by the shell:

-b file = True if the file exists and is block special file.
-c file = True if the file exists and is character special file.
-d file = True if the file exists and is a directory.
-e file = True if the file exists.
-f file = True if the file exists and is a regular file
-g file = True if the file exists and the set-group-id bit is set.
-k file = True if the files' "sticky" bit is set.
-L file = True if the file exists and is a symbolic link.
-p file = True if the file exists and is a named pipe.
-r file = True if the file exists and is readable.
-s file = True if the file exists and its size is greater than zero.
-s file = True if the file exists and is a socket.
-t fd = True if the file descriptor is opened on a terminal.
-u file = True if the file exists and its set-user-id bit is set.
-w file = True if the file exists and is writable.
-x file = True if the file exists and is executable.
-O file = True if the file exists and is owned by the effective user id.
-G file = True if the file exists and is owned by the effective group id.
file1 –nt file2 = True if file1 is newer, by modification date, than file2.
file1 ot file2 = True if file1 is older than file2.
file1 ef file2 = True if file1 and file2 have the same device and inode numbers.
-z string = True if the length of the string is 0.
-n string = True if the length of the string is non-zero.
string1 = string2 = True if the strings are equal.
string1 != string2 = True if the strings are not equal.
!expr = True if the expr evaluates to false.
expr1 –a expr2 = True if both expr1 and expr2 are true.
expr1 –o expr2 = True is either expr1 or expr2 is true.

The syntax is :

arg1 OP arg2

where OP is one of –eq, -ne, -lt, -le, -gt, or –ge. Arg1 and arg2 may be positive or negative integers or the special expression "-l string" which evaluates to the length of string.

Script Programming: Linux Script Variables

2008-11-09T19:19:00.001-08:00

When variables are used they are referred to with the $ symbol in front of them. There are several useful variables available in the shell program. Here are a few:

$$ = The PID number of the process executing the shell.
$? = Exit status variable.
$0 = The name of the command you used to call a program.
$1 = The first argument on the command line.
$2 = The second argument on the command line.
$n = The nth argument on the command line.
$* = All the arguments on the command line.
$# The number of command line arguments.

The "shift" command can be used to shift command line arguments to the left, ie $1 becomes the value of $2, $3 shifts into $2, etc. The command, "shift 2" will shift 2 places meaning the new value of $1 will be the old value of $3 and so forth.

Variable assignment

Variables are assigned in a script program as follows:

DONE=no

They are used in this manner:

while [ $DONE = no ]

Linux Script Programming

2008-11-09T19:17:00.000-08:00

Script programming is highly dependent upon the operating system shell such as bash along with the various functions (programs) installed on the system. Script programming in this section is mainly about the bash shell. The knowledge required to write script programs can be categorized into the following areas:

Working with variables
Using control and iteration statements such as "if", "while", and "until".
Performing test condition comparisons and what they mean.
Using programs installed on the system in script programs.
Using the shell capabilities:
1. Builtin commands
2. redirection and piping
3. parameter expansion

Introduction

2008-11-09T19:09:00.000-08:00

Static Definition

Blocking Definition

A blocking function is one which will pause until the criteria of the function is met. A non-blocking function will perform the operation requested if possible, but will not wait until the function is possible to carry out. An example is the reading of a port. If a blocking instruction tries to read from a port and no data is available, it will wait or block. If data is available, it will perform the read. If a non-blocking instruction tries to read a port, if no data is available, it will normally return an error or status indicator and allow the program to continue.

This section will start with a description of the Portable Operating System Interface (POSIX). The reason for the POSIX standards is to make source code portable between various operating system platforms. The POSIX standards are produced by the Institute of Electrical and Electronics Engineers (IEEE). The standards are standardized by the International Organization for Standardization (ISO) and American National Standards Institute (ANSI).

POSIX Numbering

standard	New Document #	ISO Number	Description
POSIX.1	1003.1	ISO 9945-1	Basic Interfaces
POSIX.1a	1003.1		Extensions
POSIX.2	1003.1	ISO	Commands
POSIX.3	1003.1		Test methods
POSIX.4	1003.1b		Real time
POSIX.4a	1003.1c		Threads
POSIX.4b	1003.1d		More Real time
POSIX.5	1003.1		ADA Binding
POSIX.6	1003.1e		Security
POSIX.7	1003.1		System Administration
POSIX.8	1003.1f		Network File Access
POSIX.9	1003.1		Fortran-77 Binding
POSIX.10	1003.1		Supercomputing
POSIX.12	1003.1g		Sockets
POSIX.13	1003.1		Real Time Profiles
POSIX.15	1003.1		Batch/supercomputer extensions
POSIX.17	IEEE 1224.2		Network Directory/name services

POSIX depends on:

A compiler
Headers usually in /usr/include
Libraries
An operating system that supports real time applications

POSIX Functionality

POSIX.1 Options

_POSIX_JOB_CONTROL - setpgid, tcgetgrp, tcsetpgrp
_POSIX_CHOWN_RESTRICTED - The ability to do a chown function is more restrictive
_POSIX_SAVED_IDS - A saved set-user-id and set-group-id are maintained by processes. Affects setgid, kill, fork, and setuid.
_POSIX_NO_TRUNC - Pathnames that are too long are not truncated but cause an error.
_POSIX_VDISABLE - Some special terminal characters can be disabled.
NGROUPS_MAX - Supplementary group IDs for each process can exist which may help determine file access permission.

POSIX.4 - The first item is required for POSIX.4 and the rest are options

Real time queued signals. SA_SIGINFO, SIGRTMIN, SIGRTMAX
_POSIX_REALTIME_SIGNALS - sigtimedwait, sigqueus, sigwaitinfo
_POSIX_PRIORITY_SCHEDULING - sched_getparam, sched_setparam, sched_getscheduler, sched_setscheduler, sched_rr_get_interval, sched_get_priority_min, sched_get_priority_max, sched_yield
_POSIX_TIMERS - clock_gettime, clock_settime, timer_gettime, timer_settime,clock_getres, timer_create, timer_delete, timer_getoverrun, nanosleep
_POSIX_ASYNCHRONOUS_IO - air_read, air_write, aio_error, aio_fsync, aio_cancel, aio_return, aio_suspend, lio_listio
_POSIX_PRIORITIZED_IO - Sets priorities for asynchronous I/O
_POSIX_SYNCHRONIZED_IO - If _POSIX_MAPPED_FILES (msync, fdatasync).
_POSIX_FSYNC - fsync
_POSIX_MAPPED_FILES - If _POSIX_SYNCHRONIZED_IO (mmap, munmap, msync, ftruncate)
_POSIX_MEMLOCK - mlockall, munlockall
_POSIX_MEMLOCK_RANGE - mlock, munlock
_POSIX_MEMORY_PROTECTION - mprotect
_POSIX_MESSAGE_PASSING - mq_getattr, mqset_attr, mq_open, mq_close, mq_notify, mq_send, mq_receive, mq_unlink
_POSIX_SEMAPHORES - sem_close, sem_destroy, sem_init, sem_open, sem_trywait, sem_unlink, sem_wait, sem_getvalue, sem_post.
_POSIX_SHARED_MEMORY_OBJECTS - mmap, munmap, sbm_close, sbm_open, ftruncate, sbm_unlink.

The line:

#define _POSIX_SOURCE

Indicates that the program is POSIX.1 compliant, the 1990 version of POSIX. The line:

#define _POSIX_C_SOURCE 199309

Indicates the program is POSIX.4 compliant. These lines mean only POSIX functions and symbols are used.

Man page - shmat, shmat, shmdt

2008-11-08T23:28:00.000-08:00

Tips on improving Programming Logic

2008-11-08T06:51:00.000-08:00

A lot of colleagues, friends and strangers (that I meet in meetups, etc) have asked me to explain how can they improve their programming logic.

Though programming is mainly associated with the field of Computer Science, but writing good and optimized code is mainly an art. Like all art forms requires tremendous patience and rigorous practice, building gray cells for programming logic is not much different.

I present this post/article to you on how you could too improve your programming logic.

Tip 1: Learn the language ‘C’

You might be an expert .NET, Java or PHP developer, but I would recommend that you MUST learn ‘C. We all know why ‘C’ is the most powerful programming language, but I am not recommending learning ‘C’ to you because of its power in programming.

‘C’ offers you a structured style of programming. You have one file with the main() method and the execution begins from there and the execution flow proceeds as you have directed it to.

The main advantage in ‘C’ is that it allows you to play around with memory directly. This I believe is very important if you need to understand how data is passed from one memory block to another. The reason is that you start to visualize in your minds eye how data moves in your program.

The next step is to develop programs that will help you improve your logic.

Tip 2: Develop programs that test your mind skills Ever heard of the Fibonacci series?

Ever built a program that will allow the user to type his/her name and allow to bounce off that name on the screen from one corner to another like a ball?

Ever thought of creating a library for a Menu Bar system?

All these are examples of programs that you can develop to improve your mind and programming skills.

I remember the time I was at college and I would spends nights after nights to build my own library for screen interface for menu bars, windows, text fields, etc. In a UNIX box I would use the ncurses library and build it. I would then try and replicate the same in Windows using the conio.h file and some assembly code.

Try to develop as many programs as possible in ‘C’, this will help you improve your programming logic.

Following are some programs that I can help you with:

Write a program (WAP) to find the max, min, average and total of numbers entered by the user
WAP to accept a string from the user and find the number of vowels and the vowels that got repeated the most.
WAP to accept an array of numbers and sort the same using Bubble Sort Algorithm.
WAP to accept a string from the user and print all its permutations and combinations.
WAP to accept to accept a number from the user and test if it is a Fibonacci number or not.

I can go on and on with such questions.

Tip 3: Locate code and try to understand why it was written that way

Use the internet or college library to locate code written by another developer. Try to understand why it was written that way and understand it completely. Once you have understood why it was written they way it is written, check to see if you could improve that logic.

The main objective of this exercise is to get your brain thinking.

Tip 4: Solve logic puzzles Check your local newspaper. One section of your newspaper will be filled with series of logic puzzles and riddles. Try solving them. Don’t get disheartened if you can’t solve them or take a long time to solve them. Remember that you are in the learning and improving stage. Things will be slow, but you will make progress.Your brain will be trained to think differently with every puzzle that you try to solve. This is because now you know a new method of solving. You could apply the same thinking pattern to your programs as well.

As a standard prescription, I would prescribe solving Suduku puzzles. Will help you improve your logic, concentration and skills of grouping and organizing.

Tip 5: Help other people build logic

Once you start feeling confident about yourself and your logic capabilities, you should immediately start helping people. Subscribe to a forum and start helping people there. The benefit of helping people on forums is that you get to learn new problems that people face. This immensely adds to your knowledge. Just imagine the power you would have once you start to learn problems faced by other people and how you or someone else resolved it.

I have seen friends following this advice but shying at the last moment. Why? Because they don’t want to be ridiculed in the forum. Don’t be scared of other people ridiculing you. Look at it as a learning experience. People who ridicule you would be the one’s with more experience… and learning from people who are experienced is no harm at all.

I hope this article was helpful to you.

5 skills every programmer must learn

2008-11-08T06:49:00.001-08:00

You might be the best programmer with an unbeatable logic, but there are some skills that you must obtain before it is too late.

As your age picks up, it is a bit difficult to catch up with so many technical advancements and languages that you can do when you are young. But as your grow up, your preferences would change and so would your likes towards programming and development. You slowly will look at managing than developing. You would aim to become a Project Manager or a Delivery Manager or a Vice President of a corporation. At this level programming skills become less relevant and other managerial skills become more important.

Once you reach that level, it is necessary to have some managerial skills to prove yourself in the area of management as well. Following are the skills that I feel that every programmer should aim at to grow up the corporate ladder.

1. Communication skills

Once you become a manage or start to lead a team, having good communication skills is very important. Both written and verbal. Communication is a two way process. You should learn to speak effectively and also listen. The first step is to improve your English language skills. Read this article on How to learn and improve English

2. Inter-personal skills

Inter-personal skills is the manner in which you deal and interact with others people. These people could be your clients, team mates, colleagues, seniors or your friends.

I have been a programmer myself and understand what it means to have an ‘Ego’ and ‘Shyness’. Shed these two attributes and treat each individual as you would want them to treat you. This will not only help you gain more friends, but you will also be easily accepted in various groups.

3. Time Management Skills

Like all other skills, this is also important and cannot be left aside. Every individual has 24 hours in a day. The key part of that skill is how to manage those 24 hours. We are always bombarded with work and family responsibilities. The skill is how to manage the show properly and stike a good balance to achieve all priority tasks.

I personally recommend reading the section on Time management from 7 habits of highly effective people by Steven Covey. He mentions that you should learn to schedule your priority rather than prioritize your schedule. A must read.

4. Task management skills

This skill becomes very important once you elevate yourself from being a programmer to a manager. You should learn to keep track of various tasks, not only for yourself but also of your team members.

The first step is to manage your tasks well when you are a programmer. To manage tasks you should take notes when you are given a task. Maintain a book/calender where you jot down your tasks and prioritize them. Once you complete a task; strike it off. Follow this process and it will automatically become a habit.

5. Presentation Skills

Another important skill to possess is presentation skills. As your experience grows and you start designing applications, your corporation would want you to present development ideas to clients or members of another team. You could also be asked to train internal people in skills that you are good at. In situations like these you should have good presentation skills.

Presentation skills does not get improved in a day. It requires a series of miserable failures to succeed. You should feel comfortable standing in front of a large group of people to deliver a good presentation. I would recommend that you seek opportunities withing your corporation to train people and help improve your presentation skills.

I recommend reading this article on How to power your presentation.

Conclusion:
All these skills mentioned above require a considerable amount of time, practice and failing to master. I would recommend that you start now. If you feel shy or are nervous standing in front of people and presenting, then I recommend that you seek opportunity with your current company to present an idea to a group of people or seek opportunity to train internal people; which will help you eliminate your fear of public speaking.

No matter what, don’t worry at all of what your friends or colleagues would think about you. They might mock at you or insult you, don’t worry at all. Over the next 5 years you probably wont meet them at all… so what are you scared of.

Learn, practice and improve… Best of Luck!!!

5 skills every programmer must learn

2008-11-08T06:49:00.000-08:00

You might be the best programmer with an unbeatable logic, but there are some skills that you must obtain before it is too late.

1. Communication skills

2. Inter-personal skills

Inter-personal skills is the manner in which you deal and interact with others people. These people could be your clients, team mates, colleagues, seniors or your friends.

3. Time Management Skills

4. Task management skills

This skill becomes very important once you elevate yourself from being a programmer to a manager. You should learn to keep track of various tasks, not only for yourself but also of your team members.

5. Presentation Skills

I recommend reading this article on How to power your presentation.

Learn, practice and improve… Best of Luck!!!

Twelve common programming mistakes to avoid

2008-11-08T06:44:00.001-08:00

Programming is an art and science and like all art and science the only way to learn is from mistakes. I have made many… and I would like to share with you the mistakes that I have made over my journey with development.

These are some of the most common programming mistakes made by developers (including me) and how to avoid them (not listed in any specific order)

1. Improper or No comments

Can you imagine a program without comments. Just imagine how difficult it would be to read someone else’s code without comments. The reason why we as developers miss out on comments is because when we write code, we are so engrossed in developing logic that we forget this essential step. I recommend that let you develop with the flow of logic that you have and plug in comments after you finish coding. Write comments for any and all complicated logic and SQL queries. Comments will help you a long way in reviewing your code.

2. Not reviewing your code

Once you get that big ‘AAha’ feeling looking at your code after you have completed it, it’s best to review your code immediately and try finding issues if any. You should not only review your logic but also your SQL queries. Look for instances where you have executed SELECT/UPDATE/DELETE without a WHERE clause (not a joke… this happens). For logic that is complicated you should dry run that piece of code to test if it works well.

3. Assuming Business Logic

What do we all do when we have no one from the business side to help us with Business Logic… we assume. Being proactive is good, but it could cost the client his business if you assume business logic. In situation like these its best to escalate your issues and concerns along with your assumptions to the business side and seek clarifications.

4. Not refactoring code

A silly question to ask, but here it is. How many times have our clients asked to take our sweet time to deliver a code? Well, never for me. So what do we do as developers? Develop code at the speed of thought, which results in the code being completely messed up and duplication of functions being created. I recommend that once you are done with your project and before the phase of QA begins, spend some time to refactor your code and optimize it as much as possible. This will ensure that your code is stable, reliable and reusable.

5. Not unit testing your code

Completing your code and getting ready for integration is the good part, but not unit testing your code bounces back on you when you start getting a series of integration errors. Its always better to unit test your code before you move ahead with SIT (System Integration Testing). Test functions and code separately to check if it works as desired with a range of parameters and try to automate it. Automating your unit tests will help you to execute tests whenever you make changes to your code.

6. Not maintaining list of changes

Not every developer is blessed with a code repository, though it is best to have it. In development environments where code repositories don’t exist it’s important to maintain a list of changes done on the project. Changes to files, configurations, databases, images, environment settings, etc are all important pieces of informaiton that will be required at the time of deploying to staging or production environments and its a must to record these changes in a text file. Without such a text file you can imagine the outcome of deploying to production environments and missing some changes.

7. Not indenting your code

Indenting your code is very important, its ultimately you who will maintain it later. Indenting code not only helps you to structure your code better but also helps you to read and debug your code better. You should try and get a code beautifier that will help you indent all your code as per the rules defined, thus saving you time on bigger projects.

8. Not modularizing code

Not breaking the functionality into multiple modules/functions is a big crime. Break your code into as little form as possible to complete one logical set of functionality. Your function should do what it is intended to do, nothing more - nothing less. As a rule of thumb your code per function should not exceed one page of your screen. Exceptions to this rule do exist, but keeping this rule in mind from the very beginning of development will ensure that your code as modularized to a great extent.

9. Hard coding messages and configurations

Its bad to hard code messages and configuration parameters. This effects the flexibility to change the behaviour of the application at runtime. With scripting languages like PHP it is easy to make such runtime changes. But for applications developed in Java or .NET that are compiled and deployed, it is a daunting task that can take as much as 30 - 40 minutes for deployment.

10. Not optimizing queries

I have been guilty of this too. We as developers think that writing the best code and using the most optimum function provided by the API is the only thing to do. But, we don’t realize that the time taken to execute the script is entirely dependant on how sooner your database can serve results. Therefore, I recommend that you check all your queries with the query optimizer tool that comes along with most of the database engines.

11. Not comparing files

You should always compare the modified files with the original source base. This gives you an addition opportunity to review the code and changes done and if it confirms to business logic. Configuration and function files should always be compared to see and validate the changes that have been made.

12. Not having a backup of files before upload

Without a source control software it becomes important to that you backup important files before you upload changes. Such files should include but not limited to - configuration, database and important function files.

Please feel free to share your programming experiences and write comments if you would like to share other mistakes not listed above so that developers like you and I can learn from it.

Why should every programmer upgrade knowledge

2008-11-08T06:44:00.000-08:00

In this age of competition and business flourishing, gone are those days when employers would look at someone specialized to execute projects. Though this still holds true for Architect level positions, but; employers expect a little more from programmers and software engineers.

Today knowing an array of technologies help you get a job of your choice and also helps you to negotiate a better pay package. The reason why employers prefer multi-talented employees is because not all projects is to be developed using a particular technology or language. Further, many software installations are the outcome of successful integration of various sub-systems written in different technologies.

So the question is how do you keep adding to your knowledge? How do you learn so many things and retain information? Where do you meet people to share information with you?

I recommend the following ways in which knowledge can be enhanced

1. Make a plan of action

This is the first step towards the path of enhancing your knowledge. The basis of this plan should be, a properly done research on various trends and requirements that companies follow. You need to analyze whether learning .NET is good or Java, or learning Web Services would help you or knowledge of AJAX would help you. Look at various job postings available in Daily Newspapers. Identify a pattern of technologies that various companies have a requirement for. Once you have identified technologies that you wish to learn, make a plan and execute that plan.

2. Tips on learning many technologies and retaining

This is what I do. I always compare each new procedural language to ‘C’ and each Object Oriented Language to ‘C++‘ and ‘Java‘. Use the style of associative learning. Think to yourself, if you have printf() in C - then it resembles to print or echo in PHP. This way you can make associations and retain.

Making notes for each technology so that you can revise it later as required.

3. Participate in forums

Participating in forums has a win-win situation. You not only share your knowledge, but also get to learn from it. Help as many people as possible. As a result of helping people you get to understand the subject more in depth, plus if you lack knowledge in some areas; other members of the forum supplement the missing piece of information.

4. Get into the habit of reading

Subscribe to blogs or technical news sites that publish learnings and tutorials of various technologies. Schedule time over the weekend to review articles and implement examples.

5. Participate in Meetups and conferences

A good source to add to your knowledge is to participate in meetups and conferences. Attend such events with a broad mind and accept knowledge that has been relayed. Take notes, meet people and discuss with people there. When you meet like-minded people; try to network with them and create a schedule to meetup once a month and discuss learnings.

Conclusion:
These are some of the ways in which you could improve your knowledge and skills. Over a period of time you must sharpen your axe. The field of technology is rapidly changing and one cannot always keep up to the changes and new technologies introduced. Following the above mentioned steps will help you in a big way.

Please leave behind any comments that you mind have if you have other tips as well.

Recharge your programming batteries - Tips

2008-11-08T06:21:00.001-08:00

Many of us in the field of programming and development go through a phase where we completely blank out. Our minds don’t work, our logic seems to have lost its track and we are not able to make any progress with projects. If this has happened to you and continues to happen to you… then you are not alone.

A lot of programmers and developers go through this phase on a continuous basis. I go through it at times. You could blame it on the module, your stress levels, family & personal issues, etc. But, no matter what; we still need to deliver projects on time. Clients are least interested to know what your personal problems are. They want their deliveries on time. Wouldn’t you?

Over a period of time, I have come across some tried and tested tips that will help you recharge your programming batteries. I recommend that these tips be made part of your regular programming practice, as this not only helps you to get a solution where you are badly stuck; but also relaxes your mind from the stress of thinking too much.

1. Switch off the monitor and take your book

If you cannot get a solution on your machine; try to resolve a logic issue on a book or a piece of paper. Draw flow charts and other diagrams to help you arrive at logic. Doing this will give you a new direction to look at; probably you missed a point or never thought that way.

2. Leave your development environment

At times, going away from your computer helps, as it changes the mood and freshens your mind. Continuous working on the computer at times drives you to focus on the problem so much that it keeps getting bigger. Changing the environment by either taking a walk, discussing with friends or watching some TV will help you get out of the monotony of breaking your head on a problem.

3. Play computer games

Yes, this works. Atleast for me, it always has. You can try it too. Like I mentioned earlier, it helps break the monotony of deriving a solution to your problem. Play games that get you to think and react instantaneously. A action game like Quake, DOOM, etc or a strategy based game like Age of Empires, SimCity, etc will help you in a big way

4. Meditate

Close your eyes and meditate. Taking deep breaths will help you calm down. While meditating, clear your mind of all thoughts (including the problem at hand) and relax. Feel the stress getting out of your body and mind. Think positive thoughts, visualize a place that you would like to visit for vacation.

These are some tips that I follow and hope it helps you as well. I would like to know what you do to recharge your programming batteries. Please feel free to leave behind comments for questions or if you have some tips of your own, please share; you could help others by sharing.

Man Page - read

2008-11-07T21:39:00.000-08:00

NAME
       read - read from a file descriptor

SYNOPSIS
       #include <unistd.h>

       ssize_t read(int fd, void *buf, size_t count);

DESCRIPTION
       read()  attempts to read up to count bytes from file descriptor fd into
       the buffer starting at buf.

       If count is zero, read() returns zero and has  no  other  results.   If
       count is greater than SSIZE_MAX, the result is unspecified.

RETURN VALUE
       On success, the number of bytes read is returned (zero indicates end of
       file), and the file position is advanced by this number.  It is not  an
       error  if  this  number  is smaller than the number of bytes requested;
       this may happen for example because fewer bytes are actually  available
       right  now  (maybe  because we were close to end-of-file, or because we
       are reading from a pipe, or from a terminal),  or  because  read()  was
       interrupted  by  a  signal.  On error, -1 is returned, and errno is set
       appropriately.  In this case it is left unspecified  whether  the  file
       position (if any) changes.

ERRORS
       EAGAIN Non-blocking  I/O has been selected using O_NONBLOCK and no data
              was immediately available for reading.

       EBADF  fd is not a valid file descriptor or is not open for reading.

       EFAULT buf is outside your accessible address space.

       EINTR  The call was interrupted by a signal before any data was read.

       EINVAL fd is attached to an object which is unsuitable for reading;  or
              the  file  was  opened  with  the  O_DIRECT flag, and either the
              address specified in buf, the value specified in count,  or  the
              current file offset is not suitably aligned.

       EINVAL fd  was  created  via  a call to timerfd_create(2) and the wrong
              size buffer was given to read(); see timerfd_create(2) for  fur‐
              ther information.

       EIO    I/O  error.  This will happen for example when the process is in
              a background process group, tries to read from  its  controlling
              tty,  and  either it is ignoring or blocking SIGTTIN or its pro‐
              cess group is orphaned.  It may also occur when there is a  low-
              level I/O error while reading from a disk or tape.

       EISDIR fd refers to a directory.

       Other errors may occur, depending on the object connected to fd.  POSIX
       allows a read() that is interrupted after reading some data  to  return
       -1  (with  errno set to EINTR) or to return the number of bytes already
       read.

CONFORMING TO
       SVr4, 4.3BSD, POSIX.1-2001.

NOTES
       On NFS file systems, reading small amounts of data will only update the
       time  stamp  the  first  time, subsequent calls may not do so.  This is
       caused by client side attribute caching, because most if  not  all  NFS
       clients  leave  st_atime  (last file access time) updates to the server
       and client side reads satisfied from the client’s cache will not  cause
       st_atime updates on the server as there are no server side reads.  UNIX
       semantics can be obtained by disabling client side  attribute  caching,
       but in most situations this will substantially increase server load and
       decrease performance.

       Many filesystems and disks were considered to be fast enough  that  the
       implementation  of  O_NONBLOCK  was deemed unnecessary.  So, O_NONBLOCK
       may not be available on files and/or disks.

SEE ALSO
       close(2), fcntl(2), ioctl(2), lseek(2), open(2), pread(2),  readdir(2),
       readlink(2), readv(2), select(2), write(2), fread(3)

Man page - popen

2008-11-07T21:37:00.000-08:00

NAME
       popen, pclose - process I/O

SYNOPSIS
       #include <stdio.h>

       FILE *popen(const char *command, const char *type);

       int pclose(FILE *stream);

DESCRIPTION
       The  popen()  function opens a process by creating a pipe, forking, and
       invoking the shell.  Since a pipe is by definition unidirectional,  the
       type  argument  may  specify  only  reading  or  writing, not both; the
       resulting stream is correspondingly read-only or write-only.

       The command argument is a pointer to a null-terminated string  contain‐
       ing  a shell command line.  This command is passed to /bin/sh using the
       -c flag; interpretation, if any, is performed by the shell.   The  type
       argument  is a pointer to a null-terminated string which must be either
       "r" for reading or "w" for writing.

       The return value from popen() is a normal standard I/O  stream  in  all
       respects  save  that  it  must  be  closed  with  pclose()  rather than
       fclose(3).  Writing to such a stream writes to the  standard  input  of
       the  command;  the command’s standard output is the same as that of the
       process that called popen(), unless this  is  altered  by  the  command
       itself.   Conversely,  reading  from  a "popened" stream reads the com‐
       mand’s standard output, and the command’s standard input is the same as
       that of the process that called popen().

       Note that output popen() streams are fully buffered by default.

       The pclose() function waits for the associated process to terminate and
       returns the exit status of the command as returned by wait4(2).

RETURN VALUE
       The popen() function returns NULL if the fork(2) or pipe(2) calls fail,
       or if it cannot allocate memory.

       The  pclose() function returns -1 if wait4(2) returns an error, or some
       other error is detected.

ERRORS
       The popen() function does not set errno if memory allocation fails.  If
       the  underlying  fork(2)  or pipe(2) fails, errno is set appropriately.
       If the type argument is invalid, and this condition is detected,  errno
       is set to EINVAL.

       If pclose() cannot obtain the child status, errno is set to ECHILD.

CONFORMING TO
       POSIX.1-2001.

BUGS
       Since  the  standard  input  of a command opened for reading shares its
       seek offset with the process that called popen(), if the original  pro‐
       cess  has done a buffered read, the command’s input position may not be
       as expected.  Similarly, the output from a command opened  for  writing
       may  become intermingled with that of the original process.  The latter
       can be avoided by calling fflush(3) before popen().

       Failure to execute the shell  is  indistinguishable  from  the  shell’s
       failure  to  execute command, or an immediate exit of the command.  The
       only hint is an exit status of 127.

SEE ALSO
       sh(1), fork(2),  pipe(2),  wait4(2),  fclose(3),  fflush(3),  fopen(3),
       stdio(3), system(3)

Man page - pipe

2008-11-07T21:35:00.000-08:00

NAME
       pipe - create pipe

SYNOPSIS
       #include <unistd.h>

       int pipe(int pipefd[2]);

DESCRIPTION
       pipe()  creates  a pipe, a unidirectional data channel that can be used
       for interprocess communication.  The array pipefd is used to return two
       file  descriptors  referring to the ends of the pipe.  pipefd[0] refers
       to the read end of the pipe.  pipefd[1] refers to the write end of  the
       pipe.   Data  written  to  the write end of the pipe is buffered by the
       kernel until it is read from the read end of  the  pipe.   For  further
       details, see pipe(7).

RETURN VALUE
       On  success,  zero is returned.  On error, -1 is returned, and errno is
       set appropriately.

ERRORS
       EFAULT pipefd is not valid.

       EMFILE Too many file descriptors are in use by the process.

       ENFILE The system limit on the total number  of  open  files  has  been
              reached.

CONFORMING TO
       POSIX.1-2001.

EXAMPLE
       The  following  program  creates  a pipe, and then fork(2)s to create a
       child process; the child inherits a duplicate set of  file  descriptors
       that  refer  to  the same pipe.  After the fork(2), each process closes
       the descriptors that it doesn’t need for the pipe (see  pipe(7)).   The
       parent  then  writes the string contained in the program’s command-line
       argument to the pipe, and the child reads this string a byte at a  time
       from the pipe and echoes it on standard output.

       #include <sys/wait.h>
       #include <assert.h>
       #include <stdio.h>
       #include <stdlib.h>
       #include <unistd.h>
       #include <string.h>

       int
       main(int argc, char *argv[])
       {
           int pipefd[2];
           pid_t cpid;
           char buf;

           assert(argc == 2);

           if (pipe(pipefd) == -1) {
               perror("pipe");
               exit(EXIT_FAILURE);
           }

           cpid = fork();
           if (cpid == -1) {
               perror("fork");
               exit(EXIT_FAILURE);
           }

           if (cpid == 0) {    /* Child reads from pipe */
               close(pipefd[1]);          /* Close unused write end */

               while (read(pipefd[0], &buf, 1) > 0)
                   write(STDOUT_FILENO, &buf, 1);

               write(STDOUT_FILENO, "\n", 1);
               close(pipefd[0]);
               _exit(EXIT_SUCCESS);

           } else {            /* Parent writes argv[1] to pipe */
               close(pipefd[0]);          /* Close unused read end */
               write(pipefd[1], argv[1], strlen(argv[1]));
               close(pipefd[1]);          /* Reader will see EOF */
               wait(NULL);                /* Wait for child */
               exit(EXIT_SUCCESS);
           }
       }

SEE ALSO
       fork(2), read(2), socketpair(2), write(2), popen(3), pipe(7)

Man page -open

2008-11-07T21:29:00.000-08:00

NAME
       open, creat - open and possibly create a file or device

SYNOPSIS
       #include <sys/types.h>
       #include <sys/stat.h>
       #include <fcntl.h>

       int open(const char *pathname, int flags);
       int open(const char *pathname, int flags, mode_t mode);

       int creat(const char *pathname, mode_t mode);

DESCRIPTION
       Given a pathname for a file, open() returns a file descriptor, a small,
       non-negative integer for  use  in  subsequent  system  calls  (read(2),
       write(2), lseek(2), fcntl(2), etc.).  The file descriptor returned by a
       successful call will be the lowest-numbered file  descriptor  not  cur
       rently open for the process.

       By  default,  the  new  file descriptor is set to remain open across an
       execve(2) (i.e., the  FD_CLOEXEC  file  descriptor  flag  described  in
       fcntl(2)  is  initially  disabled;  the  Linux-specific O_CLOEXEC flag,
       described below, can be used to change this default).  The file  offset
       is set to the beginning of the file (see lseek(2)).

       A  call  to open() creates a new open file description, an entry in the
       system-wide table of open files.  This entry records  the  file  offset
       and  the  file status flags (modifiable via the fcntl(2) F_SETFL opera
       tion).  A file descriptor is a reference to one of these entries;  this
       reference is unaffected if pathname is subsequently removed or modified
       to refer to a different file.  The new open file  description  is  ini
       tially  not  shared  with  any other process, but sharing may arise via
       fork(2).

       The parameter flags must include one of  the  following  access  modes:
       O_RDONLY,  O_WRONLY,  or  O_RDWR.  These request opening the file read-
       only, write-only, or read/write, respectively.

       In addition, zero or more file creation flags and file status flags can
       be bitwise-ord in flags.  The file creation flags are O_CREAT, O_EXCL,
       O_NOCTTY, and O_TRUNC.  The file status flags are all of the  remaining
       flags  listed below.  The distinction between these two groups of flags
       is that the file status flags can be retrieved and (in some cases) mod
       ified  using  fcntl(2).   The full list of file creation flags and file
       status flags is as follows:

       O_APPEND
              The file is opened in append mode.  Before  each  write(2),  the
              file  offset  is  positioned  at the end of the file, as if with
              lseek(2).  O_APPEND may lead to corrupted files on NFS file sys
              tems  if  more  than one process appends data to a file at once.
              This is because NFS does not support appending to a file, so the
              client  kernel has to simulate it, which cant be done without a
              race condition.

       O_ASYNC
              Enable signal-driven I/O: generate a signal (SIGIO  by  default,
              but  this  can  be  changed  via  fcntl(2)) when input or output
              becomes possible on this file descriptor.  This feature is  only
              available  for  terminals, pseudo-terminals, sockets, and (since
              Linux 2.6) pipes and FIFOs.  See fcntl(2) for further details.

       O_CLOEXEC (Since Linux 2.6.23)
              Enable the close-on-exec  flag  for  the  new  file  descriptor.
              Specifying  this  flag  permits a program to avoid an additional
              fcntl(2) F_SETFD operation to set the  FD_CLOEXEC  flag.   Addi
              tionally,  use  of  this flag is essential in some multithreaded
              programs since using a separate fcntl(2)  F_SETFD  operation  to
              set  the  FD_CLOEXEC  flag does not suffice to avoid race condi
              tions where one thread opens a file descriptor at the same  time
              as another thread does a fork(2) plus execve(2).

       O_CREAT
              If  the file does not exist it will be created.  The owner (user
              ID) of the file is set to the effective user ID of the  process.
              The  group  ownership  (group ID) is set either to the effective
              group ID of the process or to the group ID of the parent  direc
              tory  (depending  on  filesystem type and mount options, and the
              mode of the  parent  directory,  see,  for  example,  the  mount
              options  bsdgroups  and  sysvgroups  of  the ext2 filesystem, as
              described in mount(8)).

       O_DIRECT (Since Linux 2.6.10)
              Try to minimize cache effects of the I/O to and from this  file.
              In  general  this  will degrade performance, but it is useful in
              special situations, such  as  when  applications  do  their  own
              caching.   File I/O is done directly to/from user space buffers.
              The I/O is synchronous, that is, at the completion of a  read(2)
              or write(2), data is guaranteed to have been transferred.  Under
              Linux 2.4 transfer sizes, and the alignment of user  buffer  and
              file  offset  must all be multiples of the logical block size of
              the file system.  Under Linux 2.6 alignment to  512-byte  bound
              aries suffices.

              A  semantically  similar  (but  deprecated)  interface for block
              devices is described in raw(8).

       O_DIRECTORY
              If pathname is not a directory, cause the open  to  fail.   This
              flag is Linux-specific, and was added in kernel version 2.1.126,
              to avoid denial-of-service problems if opendir(3) is called on a
              FIFO  or  tape  device,  but  should  not be used outside of the
              implementation of opendir(3).

       O_EXCL Ensure that this call creates the file: if this flag  is  speci
              fied  in  conjunction with O_CREAT, and pathname already exists,
              then open() will fail.  The behavior of O_EXCL is  undefined  if
              O_CREAT is not specified.

              When  these two flags are specified, symbolic links are not fol
              lowed: if pathname is a symbolic link, then open() fails regard
              less of where the symbolic link points to.

              O_EXCL  is not supported on NFSv2 or on Linux before kernel 2.6;
              it is supported on Linux 2.6 and later, with NFSv3 or later.  In
              environments  where NFS O_EXCL support is not provided, programs
              that rely on it for performing locking tasks will contain a race
              condition.   Portable  programs that want to perform atomic file
              locking using a lockfile, and need to avoid reliance on NFS sup
              port  for O_EXCL, can create a unique file on the same file sys
              tem (e.g., incorporating hostname and PID), and use  link(2)  to
              make  a link to the lockfile.  If link(2) returns 0, the lock is
              successful.  Otherwise, use stat(2) on the unique file to  check
              if  its link count has increased to 2, in which case the lock is
              also successful.

       O_LARGEFILE
              (LFS) Allow files whose sizes cannot be represented in an  off_t
              (but  can  be  represented  in  an  off64_t)  to be opened.  The
              _LARGEFILE64_SOURCE macro must be defined  in  order  to  obtain
              this  definition.   Setting  the  _FILE_OFFSET_BITS feature test
              macro to 64 (rather than using  O_LARGEFILE)  is  the  preferred
              method  of  obtaining  method of accessing large files on 32-bit
              systems (see feature_test_macros(7)).

       O_NOATIME (Since Linux 2.6.8)
              Do not update the file last access time (st_atime in the  inode)
              when  the  file  is  read(2).   This flag is intended for use by
              indexing or backup programs, where  its  use  can  significantly
              reduce the amount of disk activity.  This flag may not be effec
              tive on all filesystems.  One example is NFS, where  the  server
              maintains the access time.

       O_NOCTTY
              If  pathname  refers to a terminal device  see tty(4)  it will
              not become the processs controlling terminal even if  the  pro
              cess does not have one.

       O_NOFOLLOW
              If  pathname is a symbolic link, then the open fails.  This is a
              FreeBSD extension, which was added to Linux in version  2.1.126.
              Symbolic  links in earlier components of the pathname will still
              be followed.

       O_NONBLOCK or O_NDELAY
              When possible, the file is opened in non-blocking mode.  Neither
              the  open() nor any subsequent operations on the file descriptor
              which is returned will cause the calling process to  wait.   For
              the  handling  of  FIFOs (named pipes), see also fifo(7).  For a
              discussion of the  effect  of  O_NONBLOCK  in  conjunction  with
              mandatory file locks and with file leases, see fcntl(2).

       O_SYNC The  file  is  opened for synchronous I/O.  Any write(2)s on the
              resulting file descriptor will block the calling  process  until
              the data has been physically written to the underlying hardware.
              But see NOTES below.

       O_TRUNC
              If the file already exists and is a regular file  and  the  open
              mode  allows  writing  (i.e.,  is O_RDWR or O_WRONLY) it will be
              truncated to length 0.  If the file is a FIFO or terminal device
              file,  the  O_TRUNC  flag  is  ignored.  Otherwise the effect of
              O_TRUNC is unspecified.

       Some of these optional flags can be altered using  fcntl(2)  after  the
       file has been opened.

       The  argument  mode specifies the permissions to use in case a new file
       is created.  It is modified by the processs umask in  the  usual  way:
       the  permissions if the  created file are (mode & ~umask).Note that
       this mode only applies to future accesses of the  newly  created  file;
       the  open()  call  that  creates  a  read-only  file  may well return a
       read/write file descriptor.

       The following symbolic constants are provided for mode:

       S_IRWXU
              00700 user (file owner) has read, write and execute permission

       S_IRUSR
              00400 user has read permission

       S_IWUSR
              00200 user has write permission

       S_IXUSR
              00100 user has execute permission

       S_IRWXG
              00070 group has read, write and execute permission

       S_IRGRP
              00040 group has read permission

       S_IWGRP
              00020 group has write permission

       S_IXGRP
              00010 group has execute permission

       S_IRWXO
              00007 others have read, write and execute permission

       S_IROTH
              00004 others have read permission

       S_IWOTH
              00002 others have write permission

       S_IXOTH
              00001 others have execute permission

       mode must be specified when O_CREAT is in the  flags,  and  is  ignored
       otherwise.

       creat()    is    equivalent    to    open()   with   flags   equal   to
       O_CREAT|O_WRONLY|O_TRUNC.

RETURN VALUE
       open() and creat() return the new file descriptor, or -1  if  an  error
       occurred (in which case, errno is set appropriately).

ERRORS
       EACCES The  requested access to the file is not allowed, or search per
              mission is denied for one of the directories in the path  prefix
              of  pathname,  or the file did not exist yet and write access to
              the parent directory is not  allowed.   (See  also  path_resolu
              tion(7).)

       EEXIST pathname already exists and O_CREAT and O_EXCL were used.

       EFAULT pathname points outside your accessible address space.

       EFBIG  pathname  refers  to a regular file, too large to be opened; see
              O_LARGEFILE above.  (POSIX.1-2001 specifies the error  EOVERFLOW
              for this case.)

       EISDIR pathname refers to a directory and the access requested involved
              writing (that is, O_WRONLY or O_RDWR is set).

       ELOOP  Too many symbolic links were encountered in resolving  pathname,
              or O_NOFOLLOW was specified but pathname was a symbolic link.

       EMFILE The process already has the maximum number of files open.

       ENAMETOOLONG
              pathname was too long.

       ENFILE The  system  limit  on  the  total number of open files has been
              reached.

       ENODEV pathname refers to a device special file  and  no  corresponding
              device  exists.   (This is a Linux kernel bug; in this situation
              ENXIO must be returned.)

       ENOENT O_CREAT is not set and the named file does  not  exist.   Or,  a
              directory  component in pathname does not exist or is a dangling
              symbolic link.

       ENOMEM Insufficient kernel memory was available.

       ENOSPC pathname was to be created but the  device  containing  pathname
              has no room for the new file.

       ENOTDIR
              A  component  used as a directory in pathname is not, in fact, a
              directory, or O_DIRECTORY was specified and pathname was  not  a
              directory.

       ENXIO  O_NONBLOCK  |  O_WRONLY  is set, the named file is a FIFO and no
              process has the file open for reading.  Or, the file is a device
              special file and no corresponding device exists.

       EPERM  The  O_NOATIME  flag was specified, but the effective user ID of
              the caller did not match the owner of the file  and  the  caller
              was not privileged (CAP_FOWNER).

       EROFS  pathname  refers  to  a file on a read-only filesystem and write
              access was requested.

       ETXTBSY
              pathname refers to an executable image which is currently  being
              executed and write access was requested.

       EWOULDBLOCK
              The O_NONBLOCK flag was specified, and an incompatible lease was
              held on the file (see fcntl(2)).

CONFORMING TO
       SVr4, 4.3BSD, POSIX.1-2001.  The O_CLOEXEC, O_DIRECTORY, O_NOATIME, and
       O_NOFOLLOW  flags  are  Linux-specific.   One  may  have  to define the
       _GNU_SOURCE macro to get their definitions.  O_DIRECT is not  specified
       in POSIX; one has to define _GNU_SOURCE to get its definition.

NOTES
       Under  Linux,  the O_NONBLOCK flag indicates that one wants to open but
       does not necessarily have the intention to read or write.  This is typ
       ically  used  to open devices in order to get a file descriptor for use
       with ioctl(2).

       The (undefined) effect of O_RDONLY | O_TRUNC varies  among  implementa
       tions.  On many systems the file is actually truncated.

       The  O_DIRECT  flag  was introduced in SGI IRIX, where it has alignment
       restrictions similar to those of Linux 2.4.  IRIX has also  a  fcntl(2)
       call  to  query  appropriate alignments, and sizes.  FreeBSD 4.x intro
       duced a flag of same name, but without alignment restrictions.  Support
       was  added  under  Linux in kernel version 2.4.10.  Older Linux kernels
       simply ignore this flag.  One may have to define the _GNU_SOURCE  macro
       to get its definition.

       There  are  many infelicities in the protocol underlying NFS, affecting
       amongst others O_SYNC and O_NDELAY.

       POSIX provides for three different variants of synchronized I/O, corre
       sponding to the flags O_SYNC, O_DSYNC and O_RSYNC.  Currently (2.1.130)
       these are all synonymous under Linux.

       Note that open() can open device special files, but creat() cannot cre
       ate them; use mknod(2) instead.

       On  NFS file systems with UID mapping enabled, open() may return a file
       descriptor but, for example, read(2) requests are denied  with  EACCES.
       This is because the client performs open() by checking the permissions,
       but UID mapping  is  performed  by  the  server  upon  read  and  write
       requests.

       If  the  file is newly created, its st_atime, st_ctime, st_mtime fields
       (respectively, time of last access, time of  last  status  change,  and
       time  of  last  modification; see stat(2)) are set to the current time,
       and so are the st_ctime and st_mtime fields of  the  parent  directory.
       Otherwise,  if  the  file  is modified because of the O_TRUNC flag, its
       st_ctime and st_mtime fields are set to the current time.

BUGS
       "The thing that has always disturbed me  about  O_DIRECT  is  that  the
       whole interface is just stupid, and was probably designed by a deranged
       monkey on some serious mind-controlling substances."  Linus

       Currently, it is not possible to enable signal-driven I/O by specifying
       O_ASYNC when calling open(); use fcntl(2) to enable this flag.

SEE ALSO
       close(2),  dup(2),  fcntl(2),  link(2),  lseek(2),  mknod(2), mount(2),
       mmap(2), openat(2), read(2), socket(2), stat(2),  umask(2),  unlink(2),
       write(2), fopen(3), fifo(7), feature_test_macros(7), path_resolution(7)

Man page - mkfifo

2008-11-07T21:25:00.000-08:00

NAME
       mkfifo - make a FIFO special file (a named pipe)

SYNOPSIS
       #include <sys/types.h>
       #include <sys/stat.h>

       int mkfifo(const char *pathname, mode_t mode);

DESCRIPTION
       mkfifo()  makes a FIFO special file with name pathname.  mode specifies
       the FIFO’s permissions.  It is modified by the process’s umask  in  the
       usual way: the permissions of the created file are (mode & ~umask).

       A  FIFO special file is similar to a pipe, except that it is created in
       a different way.  Instead of being an anonymous communications channel,
       a  FIFO  special  file  is  entered  into  the  file  system by calling
       mkfifo().

       Once you have created a FIFO special file in this way, any process  can
       open  it  for  reading or writing, in the same way as an ordinary file.
       However, it has to be open at both ends simultaneously before  you  can
       proceed to do any input or output operations on it.  Opening a FIFO for
       reading normally blocks until some other process opens  the  same  FIFO
       for  writing, and vice versa.  See fifo(7) for non-blocking handling of
       FIFO special files.

RETURN VALUE
       On success mkfifo() returns 0.  In the case of an error, -1 is returned
       (in which case, errno is set appropriately).

ERRORS
       EACCES One  of  the  directories in pathname did not allow search (exe‐
              cute) permission.

       EEXIST pathname already exists.

       ENAMETOOLONG
              Either the total length of pathname is greater than PATH_MAX, or
              an  individual  filename  component  has  a  length greater than
              NAME_MAX.  In the GNU system, there is no imposed limit on over‐
              all  filename  length, but some file systems may place limits on
              the length of a component.

       ENOENT A directory component in pathname does not exist or  is  a  dan‐
              gling symbolic link.

       ENOSPC The directory or filesystem has no room for the new file.

       ENOTDIR
              A  component  used as a directory in pathname is not, in fact, a
              directory.

       EROFS  pathname refers to a read-only filesystem.

CONFORMING TO
       POSIX.1-2001.

SEE ALSO
       mkfifo(1), close(2), open(2),  read(2),  stat(2),  umask(2),  write(2),
       mkfifoat(3), fifo(7)

Man page - kill

2008-11-07T21:22:00.000-08:00

NAME
       kill - send signal to a process

SYNOPSIS
       #include <sys/types.h>
       #include <signal.h>

       int kill(pid_t pid, int sig);

   Feature Test Macro Requirements for glibc (see feature_test_macros(7)):

       kill(): _POSIX_C_SOURCE || _XOPEN_SOURCE

DESCRIPTION
       The  kill()  system  call can be used to send any signal to any process
       group or process.

       If pid is positive, then signal sig is sent to pid.

       If pid equals 0, then sig is sent to every process in the process group
       of the calling process.

       If pid equals -1, then sig is sent to every process for which the call
       ing process has permission  to  send  signals,  except  for  process  1
       (init), but see below.

       If  pid  is less than -1, then sig is sent to every process in the pro
       cess group -pid.

       If sig is 0, then no signal is sent, but error checking is  still  per
       formed.

       For  a  process  to  have permission to send a signal it must either be
       privileged (under Linux: have the CAP_KILL capability), or the real  or
       effective  user  ID of the sending process must equal the real or saved
       set-user-ID of the target process.  In the case of SIGCONT it  suffices
       when the sending and receiving processes belong to the same session.

RETURN VALUE
       On success (at least one signal was sent), zero is returned.  On error,
       -1 is returned, and errno is set appropriately.

ERRORS
       EINVAL An invalid signal was specified.

       EPERM  The process does not have permission to send the signal  to  any
              of the target processes.

       ESRCH  The  pid or process group does not exist.  Note that an existing
              process might be a zombie, a  process  which  already  committed
              termination, but has not yet been wait(2)ed for.

CONFORMING TO
       SVr4, 4.3BSD, POSIX.1-2001

NOTES
       The  only  signals  that can be sent to process ID 1, the init process,
       are those for which init  has  explicitly  installed  signal  handlers.
       This is done to assure the system is not brought down accidentally.

       POSIX.1-2001  requires that kill(-1,sig) send sig to all processes that
       the calling process may send  signals  to,  except  possibly  for  some
       implementation-defined  system  processes.   Linux  allows a process to
       signal itself, but on Linux the call kill(-1,sig) does not  signal  the
       calling process.

       POSIX.1-2001  requires  that if a process sends a signal to itself, and
       the sending thread does not have  the  signal  blocked,  and  no  other
       thread  has  it  unblocked or is waiting for it in sigwait(3), at least
       one unblocked signal must be delivered to the sending thread before the
       kill().

   Linux Notes
       Across  different  kernel  versions, Linux has enforced different rules
       for the permissions required for an unprivileged process to send a sig
       nal  to  another  process.   In kernels 1.0 to 1.2.2, a signal could be
       sent if the effective user  ID  of  the  sender  matched  that  of  the
       receiver,  or  the  real  user  ID  of  the  sender matched that of the
       receiver.  From kernel 1.2.3 until 1.3.77, a signal could  be  sent  if
       the  effective  user ID of the sender matched either the real or effec
       tive user ID of the receiver.  The  current  rules,  which  conform  to
       POSIX.1-2001, were adopted in kernel 1.3.78.

BUGS
       In  2.6  kernels  up to and including 2.6.7, there was a bug that meant
       that when sending signals to a process group, kill()  failed  with  the
       error EPERM if the caller did have permission to send the signal to any
       (rather than all) of the members of the process group.  Notwithstanding
       this  error  return,  the signal was still delivered to all of the pro
       cesses for which the caller had permission to signal.

SEE ALSO
       _exit(2), killpg(2), signal(2), sigqueue(2), tkill(2),  exit(3),  capa
       bilities(7), credentials(7), signal(7)

Man page - getppid

2008-11-07T21:17:00.000-08:00

NAME
       getpid, getppid - get process identification

SYNOPSIS
       #include <sys/types.h>
       #include <unistd.h>

       pid_t getpid(void);
       pid_t getppid(void);

DESCRIPTION
       getpid() returns the process ID of the calling process.  (This is often
       used by routines that generate unique temporary filenames.)

       getppid() returns the process ID of the parent of the calling  process.

ERRORS
       These functions are always successful.

CONFORMING TO
       POSIX.1-2001, 4.3BSD, SVr4

SEE ALSO
       fork(2),  kill(2),  exec(3),  mkstemp(3),  tempnam(3), tmpfile(3), tmpnam(3), credentials(7)

Man page -fifo

2008-11-07T21:13:00.000-08:00

NAME
       fifo - first-in first-out special file, named pipe

DESCRIPTION
       A FIFO special file (a named pipe) is similar to a pipe, except that it
       is accessed as part of the file system.  It can be opened  by  multiple
       processes  for  reading or writing.  When processes are exchanging data
       via the FIFO, the kernel passes all data internally without writing  it
       to the file system.  Thus, the FIFO special file has no contents on the
       file system, the file system entry merely serves as a  reference  point
       so  that processes can access the pipe using a name in the file system.

       The kernel maintains exactly one pipe object for each FIFO special file
       that  is  opened  by  at least one process.  The FIFO must be opened on
       both ends (reading and writing) before data can be  passed.   Normally,
       opening the FIFO blocks until the other end is opened also.

       A  process can open a FIFO in non-blocking mode.  In this case, opening
       for read only will succeed even if no-one has opened on the write  side
       yet;  opening  for  write  only will fail with ENXIO (no such device or
       address) unless the other end has already been opened.

       Under Linux, opening a FIFO for read and write  will  succeed  both  in
       blocking  and non-blocking mode.  POSIX leaves this behavior undefined.
       This can be used to open a FIFO for writing while there are no  readers
       available.  A process that uses both ends of the connection in order to
       communicate with itself should be very careful to avoid deadlocks.

NOTES
       When a process tries to write to a FIFO that is not opened for read  on
       the other side, the process is sent a SIGPIPE signal.

       FIFO special files can be created by mkfifo(3), and are specially indi‐
       cated in ls -l.

SEE ALSO
       mkfifo(1), open(2), pipe(2),  sigaction(2),  signal(2),  socketpair(2),
       mkfifo(3), pipe(7)