ADVANCE LINUX PROGRAMMING:

RESOURCE MANAGEMENT UNAME: NAME uname - get name and information about current kernel SYNOPSIS #include <sys/utsname.h> int uname(struct utsname *buf); DESCRIPTION uname() returns system information in the structure pointed to by buf. The utsname struct is defined in <sys/utsname.h>: struct utsname { char sysname[]; char nodename[]; char release[]; char version[]; char machine[]; #ifdef _GNU_SOURCE char domainname[]; #endif }; The length of the arrays in a struct utsname is unspecified; the fields are terminated by a null byte ( ). RETURN VALUE On success, zero is returned. appropriately. //Program on uname #include<stdio.h> #include<string.h> #include<sys/utsname.h> #include<errno.h> main() { struct utsname buf; printf("Status: %d\n",uname(&buf)); printf("Status from errno=%d\n",errno); printf("Description:%s\n",strerror(errno)); //perror("Description:"); On error, -1 is returned, and errno is set

} output:

printf("System name=%s\n",buf.sysname); printf("Node name=%s\n",buf.nodename); printf("Release=%s\n",buf.release); printf("Version=%s\n",buf.version); printf("Machine=%s\n",buf.machine);

Status: 0 Status from errno=0 Description:Success System name=Linux Node name=Sandya Release=2.6.18-8.el5 Version=#1 SMP Fri Jan 26 14:15:21 EST 2007 Machine=i686 output -----Status: 0 Description:: Success System name=Linux Node name=Sandya Release=2.6.18-8.el5 Version=#1 SMP Fri Jan 26 14:15:21 EST 2007 Machine=i686 CTIME: NAME asctime, ctime, gmtime, localtime, mktime, asctime_r, ctime_r, gmtime_r, localtime_r - transform date and time to broken-down time or ASCII SYNOPSIS #include <time.h> char *asctime(const struct tm *tm); char *asctime_r(const struct tm *tm, char *buf); char *ctime(const time_t *timep); char *ctime_r(const time_t *timep, char *buf); struct tm *gmtime(const time_t *timep); struct tm *gmtime_r(const time_t *timep, struct tm *result); struct tm *localtime(const time_t *timep); struct tm *localtime_r(const time_t *timep, struct tm *result); time_t mktime(struct tm *tm); DESCRIPTION The ctime(), gmtime() and localtime() functions all take an argument of data type time_t which represents

calendar time. When interpreted as an absolute time value, it represents the number of seconds elapsed since 00:00:00 on January 1, 1970, Coordinated Universal Time (UTC). The asctime() and mktime() functions both take an argument representing broken-down time which is a representation separated into year, month, day, etc. Broken-down time is stored in the structure tm which is defined in <time.h> as follows: struct tm { int tm_sec; int tm_min; int tm_hour; int tm_mday; int tm_mon; int tm_year; int tm_wday; int tm_yday; int tm_isdst; }; /* seconds */ /* minutes */ /* hours */ /* day of the month */ /* month */ /* year */ /* day of the week */ /* day in the year */ /* daylight saving time */

The members of the tm structure are: tm_sec The number of seconds after the minute, normally in the range 0 to 59, but can be up to 60 to allow for leap seconds. tm_min The number of minutes after the hour, in the range 0 to 59. tm_hour The number of hours past midnight, in the range 0 to 23. tm_mday The day of the month, in the range 1 to 31. tm_mon The number of months since January, in the range 0 to 11. tm_year The number of years since 1900. tm_wday The number of days since Sunday, in the range 0 to 6. tm_yday The number of days since January 1, in the range 0 to 365. tm_isdst A flag that indicates whether daylight saving time is in effect at the time described. The value is positive if daylight saving time is in effect, zero if it is not, and negative if the information is not available. The call ctime(t) is equivalent to asctime(localtime(t)). It converts the calendar time t into a string of the form

"Wed Jun 30 21:49:08 1993\n" The return value points to a statically allocated string which might be overwritten by subsequent calls to any of the date and time functions. The function also sets the external variable tzname (see tzset(3)) with information about the current time zone. The re-entrant version ctime_r() does the same, but stores the string in a user-supplied buffer of length at least 26. It need not set tzname. The gmtime() function converts the calendar time timep to broken-down time representation, expressed in Coordinated Universal Time (UTC). It may return NULL when the year does not fit into an integer. The return value points to a statically allocated struct which might be overwritten by subsequent calls to any of the date and time functions. The gmtime_r() function does the same, but stores the data in a user-supplied struct. The localtime() function converts the calendar time timep to broken-time representation, expressed relative to the users specified time zone. The function acts as if it called tzset(3) and sets the external variables tzname with information about the current time zone, timezone with the difference between Coordinated Universal Time (UTC) and local standard time in seconds, and daylight to a non-zero value if daylight savings time rules apply during some part of the year. The return value points to a statically allocated struct which might be overwritten by subsequent calls to any of the date and time functions. The localtime_r() function does the same, but stores the data in a user-supplied struct. It need not set tzname. The asctime() function converts the broken-down time value tm into a string with the same format as ctime(). The return value points to a statically allocated string which might be overwritten by subsequent calls to any of the date and time functions. The asctime_r() function does the same, but stores the string in a user-supplied buffer of length at least 26. The mktime() function converts a broken-down time structure, expressed as local time, to calendar time representation. The function ignores the specified contents of the structure members tm_wday and tm_yday and recomputes them from the other information in the broken-down time structure. If structure members are outside their legal interval, they will be normalized (so that, e.g., 40 October is changed into 9 November). Calling mktime() also sets the external variable tzname with information about the current time zone. If the specified brokendown time cannot be represented as calendar time (seconds since the epoch), mktime() returns a value of (time_t)(-1) and does not alter the tm_wday and tm_yday members of the broken-down time structure. RETURN VALUE Each of these functions returns the value described, or NULL (-1 in case of mktime()) in case an error was detected. NOTES The four functions asctime(), ctime(), gmtime() and localtime() return a pointer to static data and hence are not thread-safe. Thread-safe versions asctime_r(), ctime_r(), gmtime_r() and localtime_r() are specified by SUSv2, and available since libc 5.2.5. //Program on time

#include<stdio.h> #include<time.h> main() { time_t p; struct tm *t; time(&p); t=localtime(&p); printf("Seconds=%d\n",t->tm_sec); printf("Minutes=%d\n",t->tm_min); printf("Hours=%d\n",t->tm_hour); printf("Day of the month=%d\n",t->tm_mday); printf("Month=%d\n",t->tm_mon+1); printf("Year=%d\n",t->tm_year+1900); printf("Week day=%d\n",t->tm_wday); printf("Day in the year=%d\n",t->tm_yday+1); } output Seconds=39 Minutes=16 Hours=1 Day of the month=13 Month=8 Year=2010 Week day=5 Day in the year=225 //Program to find week day of given date #include<stdio.h> #include<time.h> main() { time_t p; struct tm *t; //Accept date int d,m,y; printf("Enter date(dd-mm-yyyy):\n"); scanf("%d-%d-%d",&d,&m,&y); //Convert seconds obtained using time() into tm structure time(&p); t=localtime(&p); //Make changes in tm structure t->tm_mday=d; t->tm_mon=m-1;

t->tm_year=y+1900; //Convert the modified time into seconds p=mktime(t); t=localtime(&p); //Check for the week day and display switch(t->tm_wday) { case 0:printf("Sunday\n");break; case 1:printf("Monday\n");break; case 2:printf("Tuesday\n");break; case 3:printf("Wednesday\n");break; case 4:printf("Thursday\n");break; case 5:printf("Friday\n");break; case 6:printf("Saturday\n");break; }

output Enter date(dd-mm-yyyy): 12-08-2010 Thursday GETHOSTNAME,SETHOSTNAME: NAME gethostname, sethostname - get/set host name SYNOPSIS #include <unistd.h> int gethostname(char *name, size_t len); int sethostname(const char *name, size_t len); DESCRIPTION These system calls are used to access or to change the host name of the current processor. The gethostname() system call returns a null-terminated hostname (set earlier by sethostname()) in the array name that has a length of len bytes. In case the null-terminated hostname does not fit, no error is returned, but the hostname is truncated. It is unspecified whether the truncated hostname will be null-terminated. RETURN VALUE On success, zero is returned. appropriately. On error, -1 is returned, and errno is set

//Program to get hostname and set hostname #include<stdio.h> #include<unistd.h> #include<string.h>

main() { char data[50]; gethostname(data,50); printf("Host name is: %s\n",data); printf("Enter new host name:\n"); __fpurge(stdin); gets(data); sethostname(data,strlen(data)); } output: Host name is: Sandy Enter new host name: Sandya GETPWNAME,GETPWUID: NAME getpwnam, getpwnam_r, getpwuid, getpwuid_r - get password file entry SYNOPSIS #include <sys/types.h> #include <pwd.h> struct passwd *getpwnam(const char *name); struct passwd *getpwuid(uid_t uid); int getpwnam_r(const char *name, struct passwd *pwbuf, char *buf, size_t buflen, struct passwd **pwbufp); int getpwuid_r(uid_t uid, struct passwd *pwbuf, char *buf, size_t buflen, struct passwd **pwbufp); DESCRIPTION The getpwnam() function returns a pointer to a structure containing the brokenout fields of the record in the password database (e.g., the local password file /etc/passwd, NIS, and LDAP) that matches the username name. The getpwuid() function returns a pointer to a structure containing the brokenout fields of the record in the password database that matches the user ID uid. The getpwnam_r() and getpwuid_r() functions obtain the same information, but store the retrieved passwd structure in the space pointed to by pwbuf. This passwd structure contains pointers to strings, and these strings are stored in the buffer buf of size buflen. A pointer to the result (in case of success) or NULL (in case no entry was found or an error occurred) is stored in *pwbufp.

The passwd structure is defined in <pwd.h> as follows: struct passwd { char *pw_name; char *pw_passwd; uid_t pw_uid; gid_t pw_gid; char *pw_gecos; char *pw_dir; char *pw_shell; }; /* user name */ /* user password */ /* user ID */ /* group ID */ /* real name */ /* home directory */ /* shell program */

The maximum needed size for buf can be found using sysconf(3) with the _SC_GETPW_R_SIZE_MAX parameter. RETURN VALUE The getpwnam() and getpwuid() functions return a pointer to a passwd structure, or NULL if the matching entry is not found or an error occurs. If an error occurs, errno is set appropriately. If one wants to check errno after the call, it should be set to zero before the call. The return value may point to static area, and may be overwritten by subsequent calls to getpwent(), getpwnam(), or getpwuid(). The getpwnam_r() and getpwuid_r() functions return zero on success. In case of error, an error number is returned. //Program to get password entry file using username nd userid #include<stdio.h> #include<sys/types.h> #include<string.h> #include<pwd.h> main() { struct passwd *p; char name[20]; printf("Enter user name:\n"); __fpurge(stdin); gets(name); p=getpwnam(name); /* int id; printf("Enter user id:\n"); __fpurge(stdin); scanf("%d",&id); p=getpwuid); */ if(p==NULL) printf("User not available\n");

else { printf("Username:%s\n",p->pw_name); printf("Password:%s\n",p->pw_passwd); printf("User id:%d\n",p->pw_uid); printf("Group id:%d\n",p->pw_gid); printf("Real name:%s\n",p->pw_gecos); printf("Directory:%s\n",p->pw_dir); printf("Shell:%s\n",p->pw_shell);

} } output:

Enter user name: root Username:root Password:x User id:0 Group id:0 Real name:root Directory:/root Shell:/bin/bash GETPWENT: NAME getpwent, setpwent, endpwent - get password file entry SYNOPSIS #include <sys/types.h> #include <pwd.h> struct passwd *getpwent(void); void setpwent(void); void endpwent(void); DESCRIPTION The getpwent() function returns a pointer to a structure containing the brokenout fields of a record from the password database (e.g., the local password file /etc/passwd, NIS, and LDAP). The first time it is called it returns the first entry; thereafter, it returns successive entries. The setpwent() function rewinds to the beginning of the password database. The endpwent() function is used to close the password database after all processing has been performed. The passwd structure is defined in <pwd.h> as follows: struct passwd {

};

char char uid_t gid_t char char char

*pw_name; *pw_passwd; pw_uid; pw_gid; *pw_gecos; *pw_dir; *pw_shell;

/* user name */ /* user password */ /* user ID */ /* group ID */ /* real name */ /* home directory */ /* shell program */

RETURN VALUE The getpwent() function returns a pointer to a passwd structure, or NULL if there are no more entries or an error occurs. If an error occurs, errno is set appropriately. If one wants to check errno after the call, it should be set to zero before the call. //Program to get password file entries of all users #include<stdio.h> #include<sys/types.h> #include<pwd.h> main() { struct passwd *p; while((p=getpwent())!=NULL) { printf("%s:%s:%d:%d:%s:%s:%s\n",p->pw_name,p->pw_passwd,p>pw_uid,p->pw_gid,p->pw_gecos,p->pw_dir,p->pw_shell); } } output: root:x:0:0:root:/root:/bin/bash bin:x:1:1:bin:/bin:/sbin/nologin daemon:x:2:2:daemon:/sbin:/sbin/nologin adm:x:3:4:adm:/var/adm:/sbin/nologin | | sandya:x:500:500:sandya:/home/sandya:/bin/bash oracle:x:501:501::/usr/lib/oracle/xe:/bin/bash GETGRNAM,GETGRGID: NAME getgrnam, getgrnam_r, getgrgid, getgrgid_r - get group file entry SYNOPSIS #include <sys/types.h> #include <grp.h>

struct group *getgrnam(const char *name); struct group *getgrgid(gid_t gid); int getgrnam_r(const char *name, struct group *gbuf, char *buf, size_t buflen, struct group **gbufp); int getgrgid_r(gid_t gid, struct group *gbuf, char *buf, size_t buflen, struct group **gbufp); DESCRIPTION The getgrnam() function returns a pointer to a structure containing the brokenout fields of the record in the group database (e.g., the local group file /etc/group, NIS, and LDAP) that matches the group name name. The getgrgid() function returns a pointer to a structure containing the brokenout fields of the record in the group database that matches the group ID gid. The getgrnam_r() and getgrgid_r() functions obtain the same information, but store the retrieved group structure in the space pointed to by gbuf. This group structure contains pointers to strings, and these strings are stored in the buffer buf of size buflen. A pointer to the result (in case of success) or NULL (in case no entry was found or an error occurred) is stored in *gbufp. The group structure is defined in <grp.h> as follows: struct group { char *gr_name; /* group name */ char *gr_passwd; /* group password */ gid_t gr_gid; /* group ID */ char **gr_mem; /* group members */ }; The maximum needed size for buf can be found using sysconf(3) with the _SC_GETGR_R_SIZE_MAX parameter. RETURN VALUE The getgrnam() and getgrgid() functions return a pointer to a group structure, or NULL if the matching entry is not found or an error occurs. If an error occurs, errno is set appropriately. If one wants to check errno after the call, it should be set to zero before the call. The return value may point to static area, and may be overwritten by subsequent calls to getgrent(), getgrgid(), or getgrnam(). The getgrnam_r() and getgrgid_r() functions return zero on success. In case of error, an error number is returned. //Program to get group file info using group name and groupid #include<stdio.h> #include<sys/types.h> #include<string.h>

#include<grp.h> main() { struct group *g; char name[20]; int i=0; printf("Enter group name:\n"); __fpurge(stdin); gets(name); g=getgrnam(name); /* int id; printf("Enter group id:\n"); __fpurge(stdin); scanf("%d",&id); g=getgrgid(id); */ if(g==NULL) printf("Group not available\n"); else { printf("Group name:%s\n",g->gr_name); printf("Password:%s\n",g->gr_passwd); printf("Group id:%d\n",g->gr_gid); printf("Group members are:\n"); while(*(g->gr_mem+i)!=NULL) { printf("%s",*(g->gr_mem+i)); i++; } printf("\n"); }

output: Enter group name: root Group name:root Password:x Group id:0 Group members are: root output: Enter group id: 0 Group name:root Password:x

Group id:0 Group members are: root GETGRENT: --------NAME getgrent, setgrent, endgrent - get group file entry SYNOPSIS #include <sys/types.h> #include <grp.h> struct group *getgrent(void); void setgrent(void); void endgrent(void); DESCRIPTION The getgrent() function returns a pointer to a structure containing the brokenout fields of a record in the group database (e.g., the local group file /etc/group, NIS, and LDAP). The first time it is called it returns the first entry; thereafter, it returns successive entries. The setgrent() function rewinds to the beginning of the group database, to allow repeated scans. The endgrent() function is used to close the group database after all processing has been performed. The group structure is defined in <grp.h> as follows: struct group { char *gr_name; /* group name */ char *gr_passwd; /* group password */ gid_t gr_gid; /* group ID */ char **gr_mem; /* group members */ }; RETURN VALUE The getgrent() function returns a pointer to a group structure, or NULL if there are no more entries or an error occurs. Upon error, errno may be set. If one wants to check errno after the call, it should be set to zero before the call. PROCESS MANAGEMENT: FORK: NAME fork - create a child process

SYNOPSIS #include <sys/types.h> #include <unistd.h> pid_t fork(void); DESCRIPTION fork() creates a child process that differs from the parent process only in its PID and PPID, and in the fact that resource utilizations are set to 0. File locks and pending signals are not inherited. Under Linux, fork() is implemented using copy-on-write pages, so the only penalty that it incurs is the time and memory required to duplicate the parents page tables, and to create a unique task structure for the child. RETURN VALUE On success, the PID of the child process is returned in the parents thread of execution, and a 0 is returned in the childs thread of execution. On failure, a -1 will be returned in the parents context, no child process will be created, and errno will be set appropriately. //Program on fork() #include<sys/types.h> #include<unistd.h> #include<stdio.h> #include<stdlib.h> main() { int i; i=fork(); if(i==0) printf("Child process->My process id=%d\t Parent process id= %d\n",getpid(),getppid()); else printf("Parent process->My process id=%d\t My Parent process id= %d\n",getpid(),getppid()); printf("Convergence Labs\n"); __fpurge(stdin); getchar();

output: Child process->My process id=3601 Convergence Labs Parent process->My process id=3600

Parent process id=3600 My Parent process id=2947

Convergence Labs VFORK(): NAME vfork - create a child process and block parent SYNOPSIS #include <sys/types.h> #include <unistd.h> pid_t vfork(void); STANDARD DESCRIPTION (From SUSv2 / POSIX draft.) The vfork() function has the same effect as fork(), except that the behaviour is undefined if the process created by vfork() either modifies any data other than a variable of type pid_t used to store the return value from vfork(), or returns from the function in which vfork() was called, or calls any other function before successfully calling _exit() or one of the exec() family of functions. LINUX DESCRIPTION vfork(), just like fork(2), creates a child process of the calling process. For details and return value and errors, see fork(2). vfork() is a special case of clone(2). It is used to create new processes without copying the page tables of the parent process. It may be useful in performance sensitive applications where a child will be created which then immediately issues an execve(). vfork() differs from fork() in that the parent is suspended until the child makes a call to execve(2) or _exit(2). The child shares all memory with its parent, including the stack, until execve() is issued by the child. The child must not return from the current function or call exit(), but may call _exit(). Signal handlers are inherited, but not shared. Signals to the parent arrive after the child releases the parents memory. HISTORIC DESCRIPTION Under Linux, fork() is implemented using copy-on-write pages, so the only penalty incurred by fork() is the time and memory required to duplicate the parents page tables, and to create a unique task structure for the child. However, in the bad old days a fork() would require making a complete copy of the callers data space, often needlessly, since usually immediately afterwards an exec() is done. Thus, for greater efficiency, BSD introduced the vfork() system call, that did not fully copy the address space of the parent process, but borrowed the parents memory and thread of control until a call to execve() or an exit occurred. The parent process was suspended while the child was using its resources. The use of vfork() was tricky: for example, not modifying data in the parent process depended on knowing which variables are held in a register. BUGS It is rather unfortunate that Linux revived this spectre from the past. The BSD manpage states: "This system call will be eliminated when proper system

sharing mechanisms are implemented. Users should not depend on the memory sharing semantics of vfork() as it will, in that case, be made synonymous to fork()." Formally speaking, the standard description given above does not allow one to use vfork() since a following exec() might fail, and then what happens is undefined. Details of the signal handling are obscure and differ between systems. The BSD manpage states: "To avoid a possible deadlock situation, processes that are children in the middle of a vfork() are never sent SIGTTOU or SIGTTIN signals; rather, output or ioctls are allowed and input attempts result in an end-of-file indication." Currently (Linux 2.3.25), strace(1) cannot follow vfork() and requires a kernel patch. //Example 1 #include<sys/types.h> #include<unistd.h> #include<stdio.h> #include<stdlib.h> main() { int i,j; i=fork(); if(i==0) { for(j=0;j<=4;j++) { printf("%d\n",j); sleep(1); } } else { for(j=4;j>=0;j--) { printf("%d\n",j); sleep(1); } }

output: ------0 4 3 1 2 2

1 3 0 4 //Example 2 main() { int i,j; i=fork(); if(i==0) { for(j=0;j<=4;j++) //child process becomes orphan process which is taken care by init process { printf("Child\n"); sleep(1); } } else { for(j=0;j<=2;j--) { printf("Parent\n"); sleep(1); } } } output: Child Parent Child Parent Child Parent Child [root@Sandya PROCMGMT]# Child //Example 3 main() { int i,j; i=fork(); if(i==0) { for(j=0;j<=3;j++)//child process in zombie state {

printf("Child\n"); sleep(1); } else { }

} } output: Child Parent Child Parent Child Parent Child Parent Parent Parent Parent

for(j=0;j<=6;j--) { printf("Parent\n"); sleep(1); }

//Example 4 main() { int i,j; i=vfork(); if(i==0) { for(j=0;j<=2;j++) { printf("Child\n"); sleep(1); } exit(0); } else { for(j=0;j<=3;j++) { printf("Parent\n"); sleep(1); } wait(NULL);

output: Child Child Child Parent Parent Parent Parent EXECV FAMILY: NAME execl, execlp, execle, execv, execvp - execute a file SYNOPSIS #include <unistd.h> extern char **environ; int execl(const char *path, const char *arg, ...); int execlp(const char *file, const char *arg, ...); int execle(const char *path, const char *arg, ..., char * const envp[]); int execv(const char *path, char *const argv[]); int execvp(const char *file, char *const argv[]); DESCRIPTION The exec() family of functions replaces the current process image with a new process image. The functions described in this manual page are front-ends for the function execve(2). (See the manual page for execve() for detailed information about the replacement of the current process.) The initial argument for these functions is the pathname of a file which is to be executed. The const char *arg and subsequent ellipses in the execl(), execlp(), and execle() functions can be thought of as arg0, arg1, ..., argn. Together they describe a list of one or more pointers to null-terminated strings that represent the argument list available to the executed program. The first argument, by convention, should point to the filename associated with the file being executed. The list of arguments must be terminated by a NULL pointer, and, since these are variadic functions, this pointer must be cast (char *) NULL. The execv() and execvp() functions provide an array of pointers to nullterminated strings that represent the argument list available to the new program. The first argument, by convention, should point to the filename associated with the file being executed. The array of pointers must be terminated by a NULL pointer.

The execle() function also specifies the environment of the executed process by following the NULL pointer that terminates the list of arguments in the parameter list or the pointer to the argv array with an additional parameter. This additional parameter is an array of pointers to null-terminated strings and must be terminated by a NULL pointer. The other functions take the environment for the new process image from the external variable environ in the current process. Some of these functions have special semantics. The functions execlp() and execvp() will duplicate the actions of the shell in searching for an executable file if the specified filename does not contain a slash (/) character. The search path is the path specified in the environment by the PATH variable. If this variable isnt specified, the default path :/bin:/usr/bin is used. In addition, certain errors are treated specially. If permission is denied for a file (the attempted execve() returned EACCES), these functions will continue searching the rest of the search path. If no other file is found, however, they will return with the global variable errno set to EACCES. If the header of a file isnt recognized (the attempted execve() returned ENOEXEC), these functions will execute the shell with the path of the file as its first argument. (If this attempt fails, no further searching is done.) RETURN VALUE If any of the exec() functions returns, an error will have occurred. The return value is -1, and the global variable errno will be set to indicate the error. //Example sri1.c #include<stdio.h> #include<sys/types.h> #include<unistd.h> main() { int i; i=fork(); if(i==0) { printf("Press enter to replace current program\n"); __fpurge(stdin); getchar(); char *x[]={"sri","5",NULL}; //execv("sri",x); execl("sri","sri","5",NULL);

} else {

printf("I am parent process....\n");

} } sri.c

wait(NULL);

#include<stdio.h> main(int argc,char *argv[]) { int n,f=1; n=atoi(argv[1]); while(n>0) f=f*n--; printf("Factorial is %d\n",f);

Output:

THREADS PTHREAD_CREATE: NAME pthread_create - thread creation SYNOPSIS #include <pthread.h> int pthread_create(pthread_t *restrict thread, const pthread_attr_t *restrict attr, void *(*start_routine)(void*), void *restrict arg); DESCRIPTION The pthread_create() function shall create a new thread, with attributes specified by attr, within a process. If attr is NULL, the default attributes shall be used. If the attributes specified by attr are modified later, the threads attributes shall not be affected. Upon successful completion, pthread_create() shall store the ID of the created thread in the location referenced by thread. The thread is created executing start_routine with arg as its sole argument. If the start_routine returns,the effect shall be as if there was an implicit call to pthread_exit() using the return value of start_routine as the exit status. Note that the thread in which main() was originally invoked differs from this. When it returns from main(), the effect shall be as if there was an implicit call to exit() using the return value of main() as the exit status.

The signal state of the new thread shall be initialized as follows: * The signal mask shall be inherited from the creating thread. * The set of signals pending for the new thread shall be empty. The alternate stack shall not be inherited. The floating-point environment shall be inherited from the creating thread. If pthread_create() fails, no new thread is created and the contents of the location referenced by thread are undefined. If _POSIX_THREAD_CPUTIME is defined, the new thread shall have a CPU-time clock accessible, and the initial value of this clock shall be set to zero. RETURN VALUE If successful, the pthread_create() function shall return zero; otherwise, an error number shall be returned to indicate the error. PTHREAD_JOIN: NAME pthread_join - wait for thread termination SYNOPSIS #include <pthread.h> int pthread_join(pthread_t thread, void **value_ptr); DESCRIPTION The pthread_join() function shall suspend execution of the calling thread until the target thread terminates, unless the target thread has already terminated. On return from a successful pthread_join() call with a non-NULL value_ptr argument, the value passed to pthread_exit() by the terminating thread shall be made available in the location referenced by value_ptr. When a pthread_join() returns successfully, the target thread has been terminated. The results of multiple simultaneous calls to pthread_join() specifying the same target thread are undefined. If the thread calling pthread_join() is canceled, then the target thread shall not be detached. It is unspecified whether a thread that unjoined counts against {PTHREAD_THREADS_MAX}. has exited but remains

RETURN VALUE If successful, the pthread_join() function shall return zero; otherwise, an error number shall be returned to indicate the error. //Example #include<stdio.h> #include<pthread.h>

void banner() { int i; for(i=0;i<=3;i++) { printf("Banner function\n"); sleep(1); } } main() { pthread_t pd; int i; pthread_create(&pd,NULL,(void (*))banner,NULL); for(i=0;i<=3;i++) { printf("Main function\n"); sleep(1); } pthread_join(pd,NULL); } PROCESS COMMUNICATION I) RPC - SOCKETS: SOCKET: NAME socket - create an endpoint for communication SYNOPSIS #include <sys/types.h> #include <sys/socket.h> int socket(int domain, int type, int protocol); DESCRIPTION socket() creates an endpoint for communication and returns a descriptor. The domain parameter specifies a communication domain; this selects the protocol family which will be used for communication. These families are defined in <sys/socket.h>.The currently understood formats include: Name Purpose PF_UNIX, PF_LOCAL Local communication PF_INET IPv4 Internet protocols PF_INET6 IPv6 Internet protocols PF_IPX IPX - Novell protocols Man page unix(7) ip(7)

PF_NETLINK PF_X25 PF_AX25 PF_ATMPVC PF_APPLETALK PF_PACKET

Kernel user interface device netlink(7) ITU-T X.25 / ISO-8208 protocol x25(7) Amateur radio AX.25 protocol Access to raw ATM PVCs Appletalk ddp(7) Low level packet interface packet(7)

The socket has the indicated type, which specifies the communication semantics. Currently defined types are: SOCK_STREAM Provides sequenced, reliable, two-way, connection-based byte streams. An out-of-band data transmission mechanism may be supported. SOCK_DGRAM Supports datagrams (connectionless, unreliable messages of a fixed maximum length). SOCK_SEQPACKET Provides a sequenced, reliable, two-way connection-based data transmission path for datagrams of fixed maximum length; a consumer is required to read an entire packet with each read system call. SOCK_RAW Provides raw network protocol access. SOCK_RDM Provides a reliable datagram layer that does not guarantee ordering. SOCK_PACKET Obsolete and should not be used in new programs; see packet(7). Some socket types may not be implemented by all protocol families; example, SOCK_SEQPACKET is not implemented for AF_INET. for

The protocol specifies a particular protocol to be used with the socket. Normally only a single protocol exists to support a particular socket type within a given protocol family, in which case protocol can be specified as 0. However, it is possible that many protocols may exist, in which case a particular protocol must be specified in this manner. The protocol number to use is specific to the communication domain in which communication is to take place; see protocols(5). See getprotoent(3) on how to map protocol name strings to protocol numbers. Sockets of type SOCK_STREAM are full-duplex byte streams, similar to pipes. They do not preserve record boundaries. A stream socket must be in a connected state before any data may be sent or received on it. A connection to another socket is created with a connect(2) call. Once connected, data may be transferred using read(2) and write(2) calls or some variant of the send(2) and recv(2) calls. When a session has been completed a close(2) may be performed. Out-of-band data may also be transmitted as described in send(2) and received as described in recv(2).

The communications protocols which implement a SOCK_STREAM ensure that data is not lost or duplicated. If a piece of data for which the peer protocol has buffer space cannot be successfully transmitted within a reasonable length of time, then the connection is considered to be dead. When SO_KEEPALIVE is enabled on the socket the protocol checks in a protocol-specific manner if the other end is still alive. A SIGPIPE signal is raised if a process sends or receives on a broken stream; this causes naive processes, which do not handle the signal, to exit. SOCK_SEQPACKET sockets employ the same system calls as SOCK_STREAM sockets. The only difference is that read(2) calls will return only the amount of data requested, and any data remaining in the arriving packet will be discarded. Also all message boundaries in incoming datagrams are preserved. SOCK_DGRAM and SOCK_RAW sockets allow sending of datagrams to correspondents named in sendto(2) calls. Datagrams are generally received with recvfrom(2), which returns the next datagram along with the address of its sender. SOCK_PACKET is an obsolete socket type to receive raw packets directly from the device driver. Use packet(7) instead. An fcntl(2) F_SETOWN operation can be used to specify a process or process group to receive a SIGURG signal when the out-of-band data arrives or SIGPIPE signal when a SOCK_STREAM connection breaks unexpectedly. This operation may also be used to set the process or process group that receives the I/O and asynchronous notification of I/O events via SIGIO. Using F_SETOWN is equivalent to an ioctl(2) call with the FIOSETOWN or SIOCSPGRP argument. When the network signals an error condition to the protocol module (e.g., using a ICMP message for IP) the pending error flag is set for the socket. The next operation on this socket will return the error code of the pending error. For some protocols it is possible to enable a per-socket error queue to retrieve detailed information about the error; see IP_RECVERR in ip(7). The operation of sockets is controlled by socket level options. These options are defined in <sys/socket.h>. The functions setsockopt(2) and getsockopt(2) are used to set and get options, respectively. RETURN VALUE On success, a file descriptor for the new socket is returned. On error, -1 is returned, and errno is set appropriately. vi /etc/protocols ip hopopt icmp igmp ggp ipencap st tcp 0 0 1 2 3 4 5 6 IP HOPOPT ICMP IGMP GGP IP-ENCAP ST TCP # internet protocol, pseudo protocol number # hop-by-hop options for ipv6 # internet control message protocol # internet group management protocol # gateway-gateway protocol # IP encapsulated in IP (officially ``IP'') # ST datagram mode # transmission control protocol

egp igp udp BIND:

9 17

8 IGP UDP

EGP

# exterior gateway protocol # any private interior gateway (Cisco: for IGRP) # user datagram protocol

NAME bind - bind a name to a socket SYNOPSIS #include <sys/types.h> #include <sys/socket.h> int bind(int sockfd, const struct sockaddr *my_addr, socklen_t addrlen); DESCRIPTION bind() gives the socket sockfd the local address my_addr. my_addr is addrlen bytes long. Traditionally, this is called assigning a name to a socket. When a socket is created with socket(2), it exists in a name space (address family) but has no name assigned. It is normally necessary to assign a local address using bind() before a SOCK_STREAM socket may receive connections (see accept(2)). The rules used in name binding vary between address families. Consult the manual entries in Section 7 for detailed information. For AF_INET see ip(7), for AF_INET6 see ipv6(7), for AF_UNIX see unix(7), for AF_APPLETALK see ddp(7), for AF_PACKET see packet(7), for AF_X25 see x25(7) and for AF_NETLINK see netlink(7). The actual structure passed for the my_addr argument will depend on the address family. The sockaddr structure is defined as something like: struct sockaddr { sa_family_t sa_family; char sa_data[14]; } The only purpose of this structure is to cast the structure pointer passed in my_addr in order to avoid compiler warnings. The following example shows how this is done when binding a socket in the Unix (AF_UNIX) domain: #include #include #include #include <sys/socket.h> <sys/un.h> <stdlib.h> <stdlio.h>

#define MY_SOCK_PATH "/somepath" int main(int argc, char *argv[]) { int sfd; struct sockaddr_un addr;

sfd = socket(AF_UNIX, SOCK_STREAM, 0); if (sfd == -1) { perror("socket"); exit(EXIT_FAILURE); } memset(&addr, 0, sizeof(struct sockaddr_un)); /* Clear structure */ addr.sun_family = AF_UNIX; strncpy(addr.sun_path, MY_SOCK_PATH, sizeof(addr.sun_path) - 1); if (bind(sfd, (struct sockaddr *) &addr, sizeof(struct sockaddr_un)) == -1) { perror("bind"); exit(EXIT_FAILURE); } ...

RETURN VALUE On success, zero is returned. appropriately. LISTEN:

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

NAME listen - listen for connections on a socket SYNOPSIS #include <sys/socket.h> int listen(int sockfd, int backlog); DESCRIPTION To accept connections, a socket is first created with socket(2), a willingness to accept incoming connections and a queue limit for incoming connections are specified with listen(), and then the connections are accepted with accept(2). The listen() call applies only to sockets of type SOCK_STREAM or SOCK_SEQPACKET. The backlog parameter defines the maximum length the queue of pending connections may grow to. If a connection request arrives with the queue full the client may receive an error with an indication of ECONNREFUSED or, if the underlying protocol supports retransmission, the request may be ignored so that retries succeed. NOTES The behaviour of the backlog parameter on TCP sockets changed with Linux 2.2. Now it specifies the queue length for completely established sockets waiting to be accepted, instead of the number of incomplete connection requests. The maximum length of the queue for incomplete sockets can be set using the tcp_max_syn_backlog sysctl. When syncookies are enabled there is no logical maximum length and this sysctl setting is ignored. See tcp(7) for more information.

RETURN VALUE On success, zero is returned. appropriately. CONNECT:

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

NAME connect - initiate a connection on a socket SYNOPSIS #include <sys/types.h> #include <sys/socket.h> int connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen); DESCRIPTION The connect() system call connects the socket referred to by the file descriptor sockfd to the address specified by serv_addr. The addrlen argument specifies the size of serv_addr. The format of the address in serv_addr is determined by the address space of the socket sockfd; see socket(2) for further details. If the socket sockfd is of type SOCK_DGRAM then serv_addr is the address to which datagrams are sent by default, and the only address from which datagrams are received. If the socket is of type SOCK_STREAM or SOCK_SEQPACKET, this call attempts to make a connection to the socket that is bound to the address specified by serv_addr. Generally, connection-based protocol sockets may successfully connect() only once; connectionless protocol sockets may use connect() multiple times to change their association. Connectionless sockets may dissolve the association by connecting to an address with the sa_family member of sockaddr set to AF_UNSPEC. RETURN VALUE If the connection or binding succeeds, zero is returned. returned, and errno is set appropriately. ACCEPT: NAME accept - accept a connection on a socket SYNOPSIS #include <sys/types.h> #include <sys/socket.h> int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); DESCRIPTION The accept() system call is used with connection-based socket types (SOCK_STREAM, SOCK_SEQPACKET). It extracts the first connection request on the queue of pending connections, creates a new connected socket, and returns a new On error, -1 is

file descriptor referring to that socket. The newly created socket is not in the listening state. The original socket sockfd is unaffected by this call. The argument sockfd is a socket that has been created with socket(2), bound to a local address with bind(2), and is listening for connections after a listen(2). The argument addr is a pointer to a sockaddr structure. This structure is filled in with the address of the peer socket, as known to the communications layer. The exact format of the address returned addr is determined by the sockets address family (see socket(2) and the respective protocol man pages). The addrlen argument is a value-result argument: it should initially contain the size of the structure pointed to by addr; on return it will contain the actual length (in bytes) of the address returned. When addr is NULL nothing is filled in. If no pending connections are present on the queue, and the socket is not marked as non-blocking, accept() blocks the caller until a connection is present. If the socket is marked non-blocking and no pending connections are present on the queue, accept() fails with the error EAGAIN. In order to be notified of incoming connections on a socket, you can use select(2) or poll(2). A readable event will be delivered when a new connection is attempted and you may then call accept() to get a socket for that connection. Alternatively, you can set the socket to deliver SIGIO when activity occurs on a socket; see socket(7) for details. For certain protocols which require an explicit confirmation, such as DECNet, accept() can be thought of as merely dequeuing the next connection request and not implying confirmation. Confirmation can be implied by a normal read or write on the new file descriptor, and rejection can be implied by closing the new socket. Currently only DECNet has these semantics on Linux. NOTES There may not always be a connection waiting after a SIGIO is delivered or select(2) or poll(2) return a readability event because the connection might have been removed by an asynchronous network error or another thread before accept() is called. If this happens then the call will block waiting for the next connection to arrive. To ensure that accept() never blocks, the passed socket sockfd needs to have the O_NONBLOCK flag set (see socket(7)). RETURN VALUE On success, accept() returns a non-negative integer that is a descriptor for the accepted socket. On error, -1 is returned, and errno is set appropriately. SEND: NAME send, sendto, sendmsg - send a message on a socket SYNOPSIS #include <sys/types.h> #include <sys/socket.h> ssize_t send(int s, const void *buf, size_t len, int flags);

ssize_t sendto(int s, const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen); ssize_t sendmsg(int s, const struct msghdr *msg, int flags); DESCRIPTION The system calls send(), sendto(), and sendmsg() are used to transmit a message to another socket. The send() call may be used only when the socket is in a connected state (so that the intended recipient is known). The only difference between send() and write() is the presence of flags. With zero flags parameter, send() is equivalent to write(). Also, send(s,buf,len,flags) is equivalent to sendto(s,buf,len,flags,NULL,0). The parameter s is the file descriptor of the sending socket. If sendto() is used on a connection-mode (SOCK_STREAM, SOCK_SEQPACKET) socket, the parameters to and tolen are ignored (and the error EISCONN may be returned when they are not NULL and 0), and the error ENOTCONN is returned when the socket was not actually connected. Otherwise, the address of the target is given by to with tolen specifying its size. For sendmsg(), the address of the target is given by msg.msg_name, with msg.msg_namelen specifying its size. For send() and sendto(), the message is found in buf and has length len. For sendmsg(), the message is pointed to by the elements of the array msg.msg_iov. The sendmsg() call also allows sending ancillary data (also known as control information). If the message is too long to pass atomically through the underlying protocol, the error EMSGSIZE is returned, and the message is not transmitted. No indication of failure to deliver is implicit in a send(). Locally detected errors are indicated by a return value of -1. When the message does not fit into the send buffer of the socket, send() normally blocks, unless the socket has been placed in non-blocking I/O mode. In non-blocking mode it would return EAGAIN in this case. The select(2) call may be used to determine when it is possible to send more data. The flags parameter is the bitwise OR of zero or more of the following flags. MSG_CONFIRM (Linux 2.3+ only) Tell the link layer that forward progress happened: you got a successful reply from the other side. If the link layer doesnt get this it will regularly reprobe the neighbour (e.g. via a unicast ARP). Only valid on SOCK_DGRAM and SOCK_RAW sockets and currently only implemented for IPv4 and IPv6. See arp(7) for details. MSG_DONTROUTE Dont use a gateway to send out the packet, only send to hosts on directly connected networks. This is usually used only by diagnostic or routing programs. This is only defined for protocol families that route; packet sockets dont.

MSG_DONTWAIT Enables non-blocking operation; if the operation would block, EAGAIN is returned (this can also be enabled using the O_NONBLOCK with the F_SETFL fcntl(2)). MSG_EOR Terminates a record (when this notion is supported, as for sockets of type SOCK_SEQPACKET). MSG_MORE (Since Linux 2.4.4) The caller has more data to send. This flag is used with TCP sockets to obtain the same effect as the TCP_CORK socket option (see tcp(7)), with the difference that this flag can be set on a per-call basis. Since Linux 2.6, this flag is also supported for UDP sockets, and informs the kernel to package all of the data sent in calls with this flag set into a single datagram which is only transmitted when a call is performed that does not specify this flag. (See also the UDP_CORK socket option described in udp(7).) MSG_NOSIGNAL Requests not to send SIGPIPE on errors on stream oriented sockets when the other end breaks the connection. The EPIPE error is still returned. MSG_OOB Sends out-of-band data on sockets that support this notion (e.g. of type SOCK_STREAM); the underlying protocol must also support out-of-band data. The definition of the msghdr structure follows. See recv(2) and below for an exact description of its fields. struct msghdr { void *msg_name; /* optional address */ socklen_t msg_namelen; /* size of address */ struct iovec *msg_iov; /* scatter/gather array */ size_t msg_iovlen; /* # elements in msg_iov */ void *msg_control; /* ancillary data, see below */ socklen_t msg_controllen; /* ancillary data buffer len */ int msg_flags; /* flags on received message */ }; You may send control information using the msg_control and msg_controllen members. The maximum control buffer length the kernel can process is limited per socket by the net.core.optmem_max sysctl; see socket(7). RETURN VALUE On success, these calls return the number of characters sent. On error, -1 is returned, and errno is set appropriately. RECV: NAME recv, recvfrom, recvmsg - receive a message from a socket

SYNOPSIS #include <sys/types.h> #include <sys/socket.h> ssize_t recv(int s, void *buf, size_t len, int flags); ssize_t recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen); ssize_t recvmsg(int s, struct msghdr *msg, int flags); DESCRIPTION The recvfrom() and recvmsg() calls are used to receive messages from a socket, and may be used to receive data on a socket whether or not it is connectionoriented. If from is not NULL, and the underlying protocol provides the source address, this source address is filled in. The argument fromlen is a value-result parameter, initialized to the size of the buffer associated with from, and modified on return to indicate the actual size of the address stored there. The recv() call is normally used only on a connected socket (see connect(2)) and is identical to recvfrom() with a NULL from parameter. All three routines return the length of the message on successful completion. If a message is too long to fit in the supplied buffer,excess bytes may be discarded depending on the type of socket the message is received from. If no messages are available at the socket, the receive calls wait for a message to arrive, unless the socket is nonblocking (see fcntl(2)), in which case the value -1 is returned and the external variable errno set to EAGAIN. The receive calls normally return any data available, up to the requested amount, rather than waiting for receipt of the full amount requested. The select(2) or poll(2) call may be used to determine when more data arrives. The flags argument to a recv() call is formed by ORing one or more of the following values: MSG_DONTWAIT Enables non-blocking operation; if the operation would block, EAGAIN is returned (this can also be enabled using the O_NONBLOCK with the F_SETFL fcntl(2)). MSG_ERRQUEUE This flag specifies that queued errors should be received from the socket error queue. The error is passed in an ancillary message with a type dependent on the protocol (for IPv4 IP_RECVERR). The user should supply a buffer of sufficient size. The payload of the original packet that caused the error is passed as normal data via msg_iovec. The original destination address of the datagram that caused the error is supplied via msg_name.

For local errors, no address is passed (this can be checked with the cmsg_len member of the cmsghdr). For error receives, the MSG_ERRQUEUE is set in the msghdr. After an error has been passed, the pending socket error is regenerated based on the next queued error and will be passed on the next socket operation. MSG_OOB This flag requests receipt of out-of-band data that would not be received in the normal data stream. Some protocols place expedited data at the head of the normal data queue, and thus this flag cannot be used with such protocols. MSG_PEEK This flag causes the receive operation to return data from the beginning of the receive queue without removing that data from the queue. Thus, a subsequent receive call will return the same data. MSG_TRUNC Return the real length of the packet, even when it was longer than the passed buffer. Only valid for packet sockets. MSG_WAITALL This flag requests that the operation block until the full request is satisfied. However, the call may still return less data than requested if a signal is caught, an error or disconnect occurs, or the next data to be received is of a different type than that returned. As an example, Linux uses this auxiliary data mechanism to pass extended errors, IP options or file descriptors over Unix sockets. The msg_flags field in the msghdr is set on return of recvmsg(). It can contain several flags: MSG_EOR indicates end-of-record; the data returned completed a record (generally used with sockets of type SOCK_SEQPACKET). MSG_TRUNC indicates that the trailing portion of a datagram was discarded because the datagram was larger than the buffer supplied. MSG_CTRUNC indicates that some control data were discarded due to lack of space in the buffer for ancillary data. MSG_OOB is returned to indicate that expedited or out-of-band data were received. MSG_ERRQUEUE indicates that no data was received but an extended error from the socket error queue. RETURN VALUE

These calls return the number of bytes received, or -1 if an error occurred. The return value will be 0 when the peer has performed an orderly shutdown. CLOSE: NAME close - close a file descriptor SYNOPSIS #include <unistd.h> int close(int fd); DESCRIPTION close() closes a file descriptor, so that it no longer refers to any file and may be reused. Any record locks (see fcntl(2)) held on the file it was associated with, and owned by the process, are removed (regardless of the file descriptor that was used to obtain the lock). If fd is the last copy of a particular file descriptor the resources associated with it are freed; if the descriptor was the last reference to a file which has been removed using unlink(2) the file is deleted. RETURN VALUE close() returns zero on success. appropriately. On error, -1 is returned, and errno is set