#include <syslog.h>  
 void syslog(int priority, const char *message, arguments...);  

   
 #include <syslog.h>  
 #include <stdio.h>  
 #include <stdlib.h>  
 int main()  
 {  
   FILE *f;  
   f = fopen("not_here","r");  
   if(!f)  
     syslog(LOG_ERR|LOG_USER,"oops hi hi ha ha - %m\n");  
   exit(0);  
 }  
   

 $ gcc syslog.c  
 $ su  
 # ./a.out  
 # cat /var/log/messages  
 Aug 2 11:24:00 localhost a.out: oops - No such file or directory  

 #include <syslog.h>  
 void closelog(void);  
 void openlog(const char *ident, int logopt, int facility);  
 int setlogmask(int maskpri);  

 /*  
  * Option flags for openlog.  
  *  
  * LOG_ODELAY no longer does anything.  
  * LOG_NDELAY is the inverse of what it used to be.  
  */  
 #define     LOG_PID          0x01     /* log the pid with each message */  
 #define     LOG_CONS     0x02     /* log on the console if errors in sending */  
 #define     LOG_ODELAY     0x04     /* delay open until first syslog() (default) */  
 #define     LOG_NDELAY     0x08     /* don't delay open */  
 #define     LOG_NOWAIT     0x10     /* don't wait for console forks: DEPRECATED */  
 #define     LOG_PERROR     0x20     /* log to stderr as well */  

 #include <syslog.h>  
 #include <stdio.h>  
 #include <unistd.h>  
 #include <stdlib.h>  
   
 int main()  
 {  
   int logmask;  
   openlog("logmask", LOG_PID|LOG_CONS, LOG_USER);  
   
   /*  
    * ghi ra /var/log/messages  
    *  
    */  
   syslog(LOG_INFO,"informative message, pid = %d", getpid());  
   
   /*  
    * ghi ra /var/log/debug  
    *  
    */  
   syslog(LOG_DEBUG,"debug message, should appear");  
   
   /*  
    * Bỏ qua tất cả các msg có priority < LOG_NOTICE  
    *  
    */  
   logmask = setlogmask(LOG_UPTO(LOG_NOTICE));  
   syslog(LOG_DEBUG,"debug message, should not appear");  
   
   exit(0);  
 }  
   

 $ gcc logmask.c   
 $ su  
 # ./a.out   
 # cat /var/log/messages  
 Aug 2 22:14:29 localhost logmask[4676]: informative message, pid = 4676  
   

 #include <stdio.h>  
 char *tmpnam(char *s);  
 FILE *tmpfile(void);

 #include <stdio.h>  
 #include <stdlib.h>  
 int main()  
 {  
   char tmpname[L_tmpnam];  
   char *filename;  
   FILE *tmpfp;  
   filename = tmpnam(tmpname);  
   printf("Temporary file name is: %s \n", filename); //filename == tmpname  
   tmpfp = tmpfile();  
   if(tmpfp)  
     printf("Opened a temporary file OK\n");  
   else  
     perror("tmpfile");  
   exit(0);  
 }  
   

 $ gcc tmpname.c   
 $ ./a.out   
 Temporary file name is: /tmp/fileaNvouf   
 Opened a temporary file OK  
   

 #include <sys/types.h>  
 #include <unistd.h>  
 uid_t getuid(void); //trả về UID
 gid_t getgid(void); //trả về GID
 int setuid(uid_t uid);
 int setgid(gid_t gid);
 char *getlogin(void); //trả về login name của user  

 account:password:UID:GID:GECOS:directory:shell  

 $ cat /etc/passwd | grep ninhld  
 ninhld:x:1000:1000:ninhld:/home/ninhld:/bin/bash  

 #include <sys/types.h>  
 #include <pwd.h>  
 struct passwd *getpwuid(uid_t uid);  
 struct passwd *getpwnam(const char *name);  

 #include <pwd.h>  
 #include <sys/types.h>  
 void setpwent(void);           //trở về đầu database
 struct passwd *getpwent(void); //sacn tất cả entry, khi không còn thì trả về NULL
 void endpwent(void);           //đóng database khi scan xong 

 #include <sys/types.h>  
 #include <pwd.h>  
 #include <stdio.h>  
 #include <unistd.h>  
 #include <stdlib.h>  
   
 int main()  
 {  
   uid_t uid;  
   gid_t gid;  
   struct passwd *pw;  
   uid = getuid();  
   gid = getgid();  
   printf("User is %s\n", getlogin());  
   printf("User IDs: uid=%d, gid=%d\n", uid, gid);  
   pw = getpwuid(uid);  
   printf("UID passwd entry:\n name=%s, uid=%d, gid=%d, home=%s, shell=%s\n",  
       pw->pw_name, pw->pw_uid, pw->pw_gid, pw->pw_dir, pw->pw_shell);  
   pw = getpwnam("root");  
   printf("root passwd entry:\n");  
   printf("name=%s, uid=%d, gid=%d, home=%s, shell=%s\n",  
       pw->pw_name, pw->pw_uid, pw->pw_gid, pw->pw_dir, pw->pw_shell);  
   exit(0);  
 }  
   

 $ gcc user.c   
 $ ./a.out   
 User is ninhld  
 User IDs: uid=1000, gid=1000  
 UID passwd entry:  
  name=ninhld, uid=1000, gid=1000, home=/home/ninhld, shell=/bin/bash  
 root passwd entry:  
 name=root, uid=0, gid=0, home=/root, shell=/bin/bash  

 /*  
  * This program loops, reading a login name from standard  
  * input and checking to see if it is a valid name. If it  
  * is not valid, the entire contents of the name in the  
  * password database are printed.  
  */  
 #include <stdio.h>  
 #include <sys/types.h>  
 #include <pwd.h>  
   
 void main()  
 {  
   struct passwd *pw;  
   
   setpwent( );  
   while( ( pw=getpwent( ) ) != ( struct passwd * )0 )  
     printf( "%s\n", pw->pw_name );  
   endpwent();  
 }  
   

 $ gcc getpwent.c   
 $ ./a.out   
 root  
 bin  
 daemon  
 adm  
 lp  
 sync  
 shutdown  
 halt  
 mail  
 operator  
 games  
 ftp  
 nobody  
 avahi-autoipd  
 dbus  
 polkitd  
 usbmuxd  
 rtkit  
 chrony  
 tss  
 unbound  
 openvpn  
 avahi  
 pulse  
 lightdm  
 nm-openconnect  
 colord  
 sshd  
 tcpdump  
 ninhld  
 abrt  
 rpc  
 rpcuser  
 nfsnobody  
 stap-server  
   

 #include <time.h>  
 time_t time(time_t *tloc);  

 #include <time.h>  
 #include <stdio.h>  
 #include <unistd.h>  
 #include <stdlib.h>  
   
 int main()  
 {  
   int i;  
   time_t the_time, timmer;  
   for(i = 1; i <= 5; i++) {  
     the_time = time(&timmer);  
     printf("The time is %ld\n", the_time); // the_time == timmer  
     sleep(1);  
   }  
   exit(0);  
 }  
   

 $ gcc envtime.c   
 $ ./a.out   
 The time is 1438358154  
 The time is 1438358155  
 The time is 1438358156  
 The time is 1438358157  
 The time is 1438358158  
   

 #include <time.h>  
 struct tm *gmtime(const time_t timeval);  

 #include <time.h>  
 #include <stdio.h>  
 #include <stdlib.h>  
 int main()  
 {  
   struct tm *tm_ptr;  
   time_t the_time;  
   (void) time(&the_time);  
   
   tm_ptr = gmtime(&the_time);  
   printf("Raw time is %ld\n", the_time);  
   printf("gmtime gives:\n");  
   printf("date: %02d/%02d/%02d\n",  
       tm_ptr->tm_year, tm_ptr->tm_mon+1, tm_ptr->tm_mday);  
   printf("time: %02d:%02d:%02d\n",  
       tm_ptr->tm_hour, tm_ptr->tm_min, tm_ptr->tm_sec);  
   exit(0);  
 }  
   

 $ gcc gmtime.c   
 $ ./a.out   
 Raw time is 1438358295  
 gmtime gives:  
 date: 115/07/31  
 time: 15:58:15  
   

 #include <time.h>  
 char *asctime(const struct tm *timeptr);  
 char *ctime(const time_t *timeval);  

 #include <time.h>  
 #include <stdio.h>  
 #include <stdlib.h>  
 int main()  
 {  
   time_t timeval;  
   (void)time(&timeval);  
   printf("The date is: %s", ctime(&timeval));  
   exit(0);  
 }  
   

 $ gcc ctime.c   
 $ ./a.out   
 The date is: Fri Jul 31 23:00:27 2015  

 #include <time.h>  
 struct tm *localtime(const time_t *timeval);  

 /* localtime example */  
 #include <stdio.h>   /* puts, printf */  
 #include <time.h>    /* time_t, struct tm, time, localtime */  
   
 int main ()  
 {  
  time_t rawtime;  
  struct tm * timeinfo;  
   
  time (&rawtime);  
  timeinfo = localtime (&rawtime);  
  printf ("Current local time and date: %s", asctime(timeinfo));  
   
  return 0;  
 }  

 $ gcc localtime.c  
 $ ./a.out  
 Current local time and date: Fri Jul 31 16:11:47 2015  

 #include <sys/time.h>  
 int gettimeofday(struct timeval *tv, struct timezone *tz);  
 int settimeofday(const struct timeval *tv, const struct timezone *tz);  

 struct timeval {  
   time_t   tv_sec;   /* seconds */  
   suseconds_t tv_usec;  /* microseconds */  
 };  
   
 struct timezone {  
   int tz_minuteswest;   /* minutes west of Greenwich */  
   int tz_dsttime;     /* type of DST correction */  
 };  

 #include <stdio.h>  
 #include <stdlib.h>  
 #include <sys/time.h>  
   
 int main()  
 {  
   long int cycle = 2000000;//us ~ 2s  
   struct timeval tv, tv2;  
   
   gettimeofday(&tv,NULL);  
   while(1){  
     gettimeofday(&tv2,NULL);  
     if(tv2.tv_sec * 1000000 + tv2.tv_usec >= tv.tv_sec * 1000000 + tv.tv_usec + cycle){  
       printf("Timer is starting ... \n");  
       break;  
     }  
   }  
   
   return 0;  
 }  
   

 #include <stdlib.h>  
 char *getenv(const char *name);  
 int putenv(const char *string);  

 #include <stdio.h>  
 #include <stdlib.h>  
   
 int main ()  
 {  
   char *tmp;  
   
   tmp = getenv("PATH");  
   if(tmp)  
     printf("PATH : %s\n", tmp);  
   
   tmp = getenv("HOME");  
   if(tmp)  
     printf("HOME : %s\n", tmp);  
   
   tmp = getenv("ROOT");  
   if(tmp){  
     printf("ROOT : %s\n", tmp);  
   } else{  
     char *root = "ROOT=/root";  
     putenv(root);  
     printf("set ROOT : %s\n", getenv("ROOT"));  
   }  
   
   return(0);  
 }  
   

 $ gcc environ.c   
 $ ./a.out   
 PATH : /usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin  
 HOME : /home/ninhld  
 set ROOT : /root  
   

 #include <stdlib.h>  
 extern char **environ;  

 #include <stdlib.h>  
 #include <stdio.h>  
 extern char **environ;  
 int main()  
 {  
   char **env = environ;  
   while(*env) {  
     printf("%s\n",*env);  
     env++;  
   }  
   exit(0);  
 }  
   

 $ gcc showenv.c   
 $ ./a.out   
 XDG_VTNR=1  
 MATE_DESKTOP_SESSION_ID=this-is-deprecated  
 SSH_AGENT_PID=1418  
 XDG_SESSION_ID=1  
 HOSTNAME=localhost.localdomain  
 XDG_GREETER_DATA_DIR=/var/lib/lightdm-data/ninhld  
 IMSETTINGS_INTEGRATE_DESKTOP=yes  
 GPG_AGENT_INFO=/home/ninhld/.cache/keyring-PhSdLU/gpg:0:1  
 TERM=xterm-256color  
 SHELL=/bin/bash  
 HISTSIZE=1000  
 HELLO=hello  
 WINDOWID=67108895  
 OLDPWD=/home/ninhld  
 GNOME_KEYRING_CONTROL=/home/ninhld/.cache/keyring-PhSdLU  
 QTDIR=/usr/lib64/qt-3.3  
 QTINC=/usr/lib64/qt-3.3/include  
 IMSETTINGS_MODULE=IBus  
 QT_GRAPHICSSYSTEM_CHECKED=1  
 USER=ninhld  
 ...

 #include <stdio.h>  
 #include <stdlib.h>  
 int main(int argc, char **argv)  
 {  
   int arg;  
   
   printf("Program name: %s \n", argv[0]);  
   for(arg = 1; arg < argc; arg++) {  
       printf("argument %d: %s\n", arg, argv[arg]);  
   }  
   
   return 0;  
 }   

 $ gcc args.c   
 $ ./a.out par1 par2  
 Program name: ./a.out   
 argument 1: par1  
 argument 2: par2  
   

 #include <unistd.h>  
 int getopt(int argc, char *const argv[], const char *optstring);  
 extern char *optarg;  
 extern int optind, opterr, optopt;  

 getopt(argc, argv,"apl:b:")  

 #include <stdio.h>  
 #include <unistd.h>  
 #include <stdlib.h>  
   
 /*  
  *  
  * ./a.out -i -lr 'hi there' -f fred.c -q  
  *  
  * */  
 int main(int argc, char *argv[])  
 {  
   int opt;  
   while((opt = getopt(argc, argv, ":if:lr")) != -1) {  
     switch(opt) {  
     case 'i':  
     case 'l':  
     case 'r':  
       printf("option: %c\n", opt);  
       break;  
     case 'f':  
       printf("filename: %s\n", optarg);  
       break;  
     case ':':  
       printf("option needs a value\n");  
       break;  
     case '?':  
       printf("unknown option: %c\n", optopt);  
       break;  
     }  
   }  
   for(; optind < argc; optind++)  
     printf("argument: %s\n", argv[optind]);  
   exit(0);  
 }  
   

 $ gcc getopt.c  
 $ ./a.out -i  
 option: i  
 $   
 $ ./a.out -i 5  
 option: i  
 argument: 5  
 $   
 $   
 $ ./a.out -f  
 option needs a value  
 $   
 $ ./a.out -f fread.c  
 filename: fread.c  
 $   
 $ ./a.out -q  
 unknown option: q  
 $   
 $   
 $ ./a.out -lr  
 option: l  
 option: r  
 $   
 $ ./a.out -i -lr 'hi there' -f fred.c -q  
 option: i  
 option: l  
 option: r  
 filename: fred.c  
 unknown option: q  
 argument: hi there  
   

 #include <unistd.h>  
 #include <stdio.h>  
 #include <stdlib.h>  
 #include <getopt.h>  
   
 /** Program to calculate the area and perimeter of   
  * a rectangle using command line arguments  
  */  
 void print_usage() {  
   printf("Usage: rectangle [ap] -l num -b num\n");  
 }  
   
 int main(int argc, char *argv[]) {  
   int option = 0;  
   int area = -1, perimeter = -1, breadth = -1, length =-1;  
   
   //Specifying the expected options  
   //The two options l and b expect numbers as argument  
   while ((option = getopt(argc, argv,"apl:b:")) != -1) {  
     switch (option) {  
        case 'a' : area = 0;  
          break;  
        case 'p' : perimeter = 0;  
          break;  
        case 'l' : length = atoi(optarg);   
          break;  
        case 'b' : breadth = atoi(optarg);  
          break;  
        default: print_usage();   
          exit(EXIT_FAILURE);  
     }  
   }  
   if (length == -1 || breadth ==-1) {  
     print_usage();  
     exit(EXIT_FAILURE);  
   }  
   
   // Calculate the area  
   if (area == 0) {  
     area = length * breadth;  
     printf("Area: %d\n",area);  
   }  
   
   // Calculate the perimeter  
   if (perimeter == 0) {  
     perimeter = 2 * (length + breadth);  
     printf("Perimeter: %d\n",perimeter);  
   }  
   return 0;  
 }  

 struct option {  
   const char *name;  
   int has_arg;  
   int *flag;  
   int val;  
 };  

 #include <stdio.h>  
 #include <unistd.h>  
 #include <stdlib.h>  
   
 #define _GNU_SOURCE  
 #include <getopt.h>  
   
 /*  
  *  
  * ./longopt --init –l --file=fred.c 'hi there'  
  *  
  * */  
 int main(int argc, char *argv[])  
 {  
   int opt;  
   struct option longopts[] = {  
   {"initialize", 0, NULL, 'i'},  
   {"file", 1, NULL, 'f'},  
   {"list", 0, NULL, 'l'},  
   {"restart", 0, NULL, 'r'},  
   {0,0,0,0}};  
   while((opt = getopt_long(argc, argv, ":if:lr", longopts, NULL)) != -1) {  
     switch(opt) {  
     case 'i':  
     case 'l':  
     case 'r':  
       printf("option: %c\n", opt);  
       break;  
     case 'f':  
       printf("filename: %s\n", optarg);  
       break;  
     case ':':  
       printf("option needs a value\n");  
       break;  
     case '?':  
       printf("unknown option: %c\n", optopt);  
       break;  
     }  
   }  
   for(; optind < argc; optind++)  
     printf("argument: %s\n", argv[optind]);  
   exit(0);  
 }  
   

 $ ./longopt --init –l --file=fred.c ‘hi there’  
 option: i  
 option: l  
 filename: fred.c  
 argument: hi there  

 #include <unistd.h>   
 #include <fcntl.h>   
   
 int fcntl(int fd, int cmd);   
 int fcntl(int fd, int cmd, long arg);   
 int fcntl(int fd, int cmd, struct flock *lock);   

 #include <sys/mman.h>   
   
 void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);   
 int munmap(void *start, size_t length);   

 #include <string.h>  
 char *strerror(int errnum);  

 #include <stdio.h>  
 void perror(const char *s);  

 #include<stdio.h>  
 #include<errno.h>  
 #include<string.h>  
   
 int main(void)  
 {  
   FILE *fd = NULL;  
   
   // Reset errno to zero before calling fopen().  
   errno = 0;  
   
   // Lets open a file that does not exist  
   fd = fopen("Linux.txt","r");  
   if(errno || (NULL == fd))  
   {  
     // Use strerror to display the error string  
   
 #if 1  
     perror("The function fopen failed due to");  
 #else  
     printf("The function fopen failed due to %s \n", strerror(errno));  
 #endif  
     return -1;  
   }  
   
   return 0;  
 }  
   

 #include <sys/types.h>  
 #include <dirent.h>  
 DIR *opendir(const char *name);  

 #include <sys/types.h>  
 #include <dirent.h>  
 struct dirent *readdir(DIR *dirp);  

 #include <sys/types.h>  
 #include <dirent.h>  
 long int telldir(DIR *dirp);

 #include <sys/types.h>  
 #include <dirent.h>  
 void seekdir(DIR *dirp, long int loc);  

 #include <sys/types.h>  
 #include <dirent.h>  
 int closedir(DIR *dirp); 

 #include <unistd.h>  
 #include <stdio.h>  
 #include <dirent.h>  
 #include <string.h>  
 #include <sys/stat.h>  
 #include <stdlib.h>  
   
 void printdir(char *dir, int depth)  
 {  
   DIR *dp;  
   struct dirent *entry;  
   struct stat statbuf;  
   if((dp = opendir(dir)) == NULL) {  
     fprintf(stderr,"cannot open directory: %s\n", dir);  
     return;  
   }  
   chdir(dir);  
   while((entry = readdir(dp)) != NULL) {  
     lstat(entry->d_name,&statbuf);  
     if(S_ISDIR(statbuf.st_mode)) {  
       /* Found a directory, but ignore . and .. */  
       if(strcmp(".",entry->d_name) == 0 ||  
           strcmp("..",entry->d_name) == 0)  
         continue;  
       printf("%*s%s/\n",depth,"",entry->d_name);  
       /* Recurse at a new indent level */  
       printdir(entry->d_name,depth+4);  
     }  
     else printf("%*s%s\n",depth,"",entry->d_name);  
   }  
   chdir("..");  
   closedir(dp);  
 }  
   
 int main(int argc, char **argv)  
 {  
   if(argc != 2) return;  
   printf("Directory scan of %s:\n", argv[1]);  
   printdir(argv[1],0);  
   exit(0);  
 }  
   

 $ gcc scandir.c   
 $ ./a.out /home/ninhld/Github/eslinuxprogramming  
 Directory scan of /home/ninhld/Github/eslinuxprogramming:  
 simple_read.c  
 gets.c  
 dup2.c  
 dup.c  
 chmod.c   
 lseek.c  

 #include <sys/stat.h>  
 int chmod(const char *path, mode_t mode);  

 S_IRUSR                    /* Read by owner. */  
 S_IWUSR                    /* Write by owner. */  
 S_IXUSR                    /* Execute by owner. */  
   
 S_IRGRP                    /* Read by group. */  
 S_IWGRP                    /* Write by group. */  
 S_IXGRP                    /* Execute by group. */  
   
 S_IROTH                    /* Read by others. */  
 S_IWOTH                    /* Write by others. */  
 S_IXOTH                    /* Execute by others. */  

 #include <stdio.h>  
 #include <sys/stat.h>  
   
 int main(int argc, char **argv)  
 {  
   
   const char *path="/home/ninhld/Github/eslinuxprogramming/testfile.txt";  
   chmod(path, S_IRUSR|S_IRGRP|S_IROTH);  
   
   return 0;  
 }  
   

 $ ls -l  
 total 68  
 -rwxr-xr-x. 1 ninhld ninhld 139 Jul 26 10:21 testfile.txt  
 $   
 $ gcc chmod.c   
 $ ./a.out   
 $ ls -l  
 total 68  
 -r--r--r--. 1 ninhld ninhld 139 Jul 26 10:21 testfile.txt  

 #include <sys/types.h>  
 #include <unistd.h>  
 int chown(const char *path, uid_t owner, gid_t group);  

 #include <stdio.h>  
 #include <sys/stat.h>  
 #include <sys/types.h>  
 #include <unistd.h>  
   
 int main(int argc, char **argv)  
 {  
   
   
   uid_t uid = getuid();  
   gid_t gid = getgid();  
   
   printf("current uid: %d, gid: %d \n", uid, gid);  
   
   int ret;  
   ret = chown("/home/ninhld/Github/eslinuxprogramming/testfile.txt",  
      0,  
      0);  
   printf("ret: %d \n", ret);  
   
   
   return 0;  
 }  
   

 $ ls -l  
 total 72  
 -rwxr-xr-x. 1 ninhld ninhld 139 Jul 26 10:21 testfile.txt  
 $   
 $ gcc chown.c   
 $ su  
 #   
 # ./a.out   
 current uid: 0, gid: 0   
 ret: 0   
 #   
 # ls -l  
 total 72  
 -rwxr-xr-x. 1 root  root  139 Jul 26 10:21 testfile.txt  
   

 #include <unistd.h>  
 int unlink(const char *path);  
 int link(const char *path1, const char *path2);  
 int symlink(const char *path1, const char *path2);  

 #include <stdio.h>  
 #include <unistd.h>  
   
 int main(int argc, char **argv)  
 {  
   
   const char *from = "/home/ninhld/Github/eslinuxprogramming/testfile.txt";  
   const char *to = "/home/ninhld/Github/eslinuxprogramming/test-file.txt";  
   
   int ret = link(from, to); //or symlink
   printf("ret: %d \n", ret);  
   
   return 0;  
 }  
   

 #include <sys/types.h>  
 #include <sys/stat.h>  
 int mkdir(const char *path, mode_t mode);  

 #include <unistd.h>  
 int rmdir(const char *path);  

 #include <unistd.h>  
 int chdir(const char *path);
 char *getcwd(char *buf, size_t size);  

 #include <stdio.h>  
 int printf(const char *format, ...);  
 int sprintf(char *s, const char *format, ...);  
 int fprintf(FILE *stream, const char *format, ...);  

 /* sprintf example */  
 #include <stdio.h>  
   
 int main ()  
 {  
  char buffer [50];  
  int n, a=5, b=3;  
  n=sprintf (buffer, "%d plus %d is %d", a, b, a+b);  
  printf ("[%s] is a string %d chars long\n",buffer,n);  
  return 0;  
 }  

 /* fprintf example */  
 #include <stdio.h>  
   
 int main ()  
 {  
   FILE * pFile;  
   int n;  
   char name [100];  
   
   pFile = fopen ("myfile.txt","w");  
   for (n=0 ; n<3 ; n++)  
   {  
    puts ("please, enter a name: ");  
    gets (name);  
    fprintf (pFile, "Name %d [%-10.10s]\n",n+1,name);  
   }  
   fclose (pFile);  
   
   return 0;  
 }  

 #include <stdio.h>  
 int scanf(const char *format, ...); 
 int sscanf(const char *s, const char *format, ...); 
 int fscanf(FILE *stream, const char *format, ...);     

 /* scanf example */  
 #include <stdio.h>  
   
 int main ()  
 {  
  char str [80];  
  int i;  
   
  printf ("Enter your family name: ");  
  scanf ("%79s",str);   
  printf ("Enter your age: ");  
  scanf ("%d",&i);  
  printf ("Mr. %s , %d years old.\n",str,i);  
  printf ("Enter a hexadecimal number: ");  
  scanf ("%x",&i);  
  printf ("You have entered %#x (%d).\n",i,i);  
    
  return 0;  
 }  

 /* sscanf example */  
 #include <stdio.h>  
   
 int main ()  
 {  
  char sentence []="Rudolph is 12 years old";  
  char str [20];  
  int i;  
   
  sscanf (sentence,"%s %*s %d",str,&i);  
  printf ("%s -> %d\n",str,i);  
    
  return 0;  
 }  

 /* fscanf example */  
 #include <stdio.h>  
   
 int main ()  
 {  
  char str [80];  
  float f;  
  FILE * pFile;  
   
  pFile = fopen ("myfile.txt","w+");  
  fprintf (pFile, "%f %s", 3.1416, "PI");  
  rewind (pFile);  
  fscanf (pFile, "%f", &f);  
  fscanf (pFile, "%s", str);  
  fclose (pFile);  
  printf ("I have read: %f and %s \n",f,str);  
  return 0;  
 }  

 #include <stdio.h>  
 FILE *fopen(const char *filename, const char *mode);  

 #include <stdio.h>  
 size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);  

 #include <stdio.h>  
 #include <string.h>  
   
 int main()  
 {  
   FILE *fp = NULL;  
   int nread;  
   char buffer[100];  
   memset(buffer, '\0', sizeof(buffer));  
   
   /* Open file for both reading */  
   fp = fopen("testfile.dt", "rb");  
   if(!fp) return 1;  
   
   /* Read and display data */  
   nread = fread(buffer, sizeof(char), 100, fp);  
   printf("nread: %d, str: %s\n", nread, buffer);  
   
   memset(buffer, '\0', sizeof(buffer));  
   nread = fread(buffer, sizeof(char)*2, 10, fp);  
   printf("nread: %d, str: %s\n", nread, buffer);  
   
   fclose(fp);  
   return(0);  
 }  
   

 #include <stdio.h>  
 size_t fwrite (const void *ptr, size_t size, size_t nitems, FILE *stream);  

 /* fwrite example : write buffer */  
 #include <stdio.h>  
   
 int main ()  
 {  
  FILE * pFile;  
  char buffer[] = { 'x' , 'y' , 'z' };  
  pFile = fopen ("myfile.bin", "wb");  
  fwrite (buffer , sizeof(char), sizeof(buffer), pFile);  
  fclose (pFile);  
  return 0;  
 }  

 #include <stdio.h>  
 int fclose(FILE *stream);  

 #include <stdio.h>  
 int fflush(FILE *stream);  

 /* fflush example */  
 #include <stdio.h>  
 char mybuffer[80];  
 int main()  
 {  
   FILE * pFile;  
   pFile = fopen ("example.txt","r+");  
   if (pFile == NULL) perror ("Error opening file");  
   else {  
    fputs ("test",pFile);  
    fflush (pFile);  // flushing or repositioning required  
    fgets (mybuffer,80,pFile);  
    puts (mybuffer);  
    fclose (pFile);  
    return 0;  
  }  
 }  

 #include <stdio.h>  
 int fseek(FILE *stream, long int offset, int whence);  

 /* fseek example */  
 #include <stdio.h>  
   
 int main ()  
 {  
  FILE * pFile;  
  pFile = fopen ( "example.txt" , "wb" );  
  fputs ( "This is an apple." , pFile );  
  fseek ( pFile , 9 , SEEK_SET );  
  fputs ( " sam" , pFile );  
  fclose ( pFile );  
  return 0;  
 }  

 #include <stdio.h>  
 int fgetc(FILE *stream);  
 int getc(FILE *stream);  
 int getchar();  

 /* fgetc example: money counter */  
 #include <stdio.h>  
 int main ()  
 {  
  FILE * pFile;  
  int c;  
  int n = 0;  
  pFile=fopen ("myfile.txt","r");  
  if (pFile==NULL) perror ("Error opening file");  
  else  
  {  
   do {  
    c = fgetc (pFile);  
    if (c == '$') n++;  
   } while (c != EOF);  
   fclose (pFile);  
   printf ("The file contains %d dollar sign characters ($).\n",n);  
  }  
  return 0;  
 }  

 /* getc example: money counter */  
 #include <stdio.h>  
 int main ()  
 {  
  FILE * pFile;  
  int c;  
  int n = 0;  
  pFile=fopen ("myfile.txt","r");  
  if (pFile==NULL) perror ("Error opening file");  
  else  
  {  
   do {  
    c = getc (pFile);  
    if (c == '$') n++;  
   } while (c != EOF);  
   fclose (pFile);  
   printf ("File contains %d$.\n",n);  
  }  
  return 0;  
 }  

 /* getchar example : typewriter */  
 #include <stdio.h>  
   
 int main ()  
 {  
  int c;  
  puts ("Enter text. Include a dot ('.') in a sentence to exit:");  
  do {  
   c=getchar();  
   putchar (c);  
  } while (c != '.');  
  return 0;  
 }  

 #include <stdio.h>  
 int fputc(int c, FILE *stream);  
 int putc(int c, FILE *stream);  
 int putchar(int c);  

 /* fputc example: alphabet writer */  
 #include <stdio.h>  
   
 int main ()  
 {  
  FILE * pFile;  
  char c;  
   
  pFile = fopen ("alphabet.txt","w");  
  if (pFile!=NULL) {  
   
   for (c = 'A' ; c <= 'Z' ; c++)  
    fputc ( c , pFile );  
   
   fclose (pFile);  
  }  
  return 0;  
 }  

 /* putc example: alphabet writer */  
 #include <stdio.h>  
   
 int main ()  
 {  
  FILE * pFile;  
  char c;  
   
  pFile=fopen("alphabet.txt","wt");  
  for (c = 'A' ; c <= 'Z' ; c++) {  
   putc (c , pFile);  
   }  
  fclose (pFile);  
  return 0;  
 }  

 /* putchar example: printing the alphabet */  
 #include <stdio.h>  
   
 int main ()  
 {  
  char c;  
  for (c = 'A' ; c <= 'Z' ; c++) putchar (c);  
   
  return 0;  
 }  

 #include <stdio.h>  
 char *fgets(char *s, int n, FILE *stream);  
 char *gets(char *s);  

 /* fgets example */  
 #include <stdio.h>  
   
 int main()  
 {  
   FILE * pFile;  
   char mystring [100];  
   
   pFile = fopen ("testfile.txt" , "r");  
   if (pFile == NULL) perror ("Error opening file");  
   else {  
     if ( fgets (mystring , 10 , pFile) != NULL )  
       puts (mystring);  
     fclose (pFile);  
   }  
   return 0;  
 }  
   

 /* gets example */  
 #include <stdio.h>  
   
 int main()  
 {  
   char string [256];  
   printf ("Insert your full address: ");  
   gets (string);   // warning: unsafe (see fgets instead)  
   printf ("Your address is: %s\n",string);  
   return 0;  
 }  
   

 # include <stdio.h>  
 int fputs ( const char * str, FILE * stream );  
 int puts ( const char * str );  

 /* fputs example */  
 #include <stdio.h>  
   
 int main ()  
 {  
   FILE * pFile;  
   char sentence [256];  
   
   printf ("Enter sentence to append: ");  
   fgets (sentence,256,stdin);  
   pFile = fopen ("mylog.txt","a");  
   fputs (sentence,pFile);  
   fclose (pFile);  
   return 0;  
 }  

 /* puts example : hello world! */  
 #include <stdio.h>  
   
 int main ()  
 {  
  char string [] = "Hello world!";  
  puts (string);  
 }  

 #!/bin/sh   
 echo "Type your name !"  
 read your_name  
 echo "Your name: $your_name"  

 $ ./test.sh   
 Type your name !  
 Obama  
 Your name: Obama  

 #include <fcntl.h>  
 #include <sys/types.h>  
 #include <sys/stat.h>  
   
 int open(const char *path, int oflags);              //(1)
 int open(const char *path, int oflags, mode_t mode); //(2)
 int creat(const char *pathname, mode_t mode);        //(3)

 open("/home/ninhld/Documents/test.txt", O_WRONLY);  
 open("/dev/ttyUSB0", O_RDWR);  

 open ("/home/ninhld/Documents/test.txt", O_CREAT, S_IRUSR|S_IXOTH);  

 #include <unistd.h>  
 size_t write(int fildes, const void *buf, size_t nbytes);  

 #include <unistd.h>  
 #include <stdlib.h>  
   
 /*  
  * write string to standard output / error (screen)  
  */  
 int main()  
 {  
   if ((write(1, "Here is some data\n", 18)) != 18)  
     write(2, "A write error has occurred on file descriptor 1\n",46);  
   exit(0);  
 }  
   

 $ gcc simple_write.c   
 $ ./a.out   
 Here is some data  
   

 #include <unistd.h>  
 size_t read(int fildes, void *buf, size_t nbytes);  

 #include <unistd.h>  
 #include <stdlib.h>  
   
 /*  
  * read from standard input (keyboard)  
  * write to standard output (screen)  
  */  
   
 int main()  
 {  
   char buffer[128];  
   int nread;  
   nread = read(0, buffer, 128);  
   if (nread == -1)  
     write(2, "A read error has occurred\n", 26);  
   if ((write(1,buffer,nread)) != nread)  
     write(2, "A write error has occurred\n",27);  
   exit(0);  
 }  

 $ gcc simple_read.c   
 $ ./a.out   
 hello     
 hello  
   

 #include <unistd.h>  
 int ioctl(int fildes, int cmd, ...);  

 ioctl(sock_fd, CMD_SET, &data);  

 #include <unistd.h>  
 int close(int fildes);  

 #include <unistd.h>  
 #include <sys/stat.h>  
 #include <fcntl.h>  
 #include <stdlib.h>  
   
 int main()  
 {  
   char c;  
   int in, out;  
   in = open("file.in", O_RDONLY);  
   out = open("file.out", O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR);  
   while(read(in,&c,1) == 1)  
     write(out,&c,1);  
   exit(0);  
 }  
   

 #include <unistd.h>  
 #include <sys/stat.h>  
 #include <fcntl.h>  
 #include <stdlib.h>  
   
 int main()  
 {  
   char block[1024];  
   int in, out;  
   int nread;  
   in = open("file.in", O_RDONLY);  
   out = open("file.out", O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR);  
   while((nread = read(in,block,sizeof(block))) > 0)  
     write(out,block,nread);  
   exit(0);  
 }  
   

 #include <unistd.h>  
 #include <sys/types.h>  
 off_t lseek(int fildes, off_t offset, int whence);  

 #include <stdio.h>  
 #include <unistd.h>  
 #include <fcntl.h>  
 #include <sys/types.h>   
 int main()  
 {  
   int file=0;  
   if((file=open("testfile.txt",O_RDONLY)) < -1)  
     return 1;  
   
   char buffer[19];  
   if(read(file,buffer,19) != 19) return 1;  
   printf("%s\n",buffer);  
   
   if(lseek(file,10,SEEK_SET) < 0) return 1;  
   
   if(read(file,buffer,19) != 19) return 1;  
   printf("%s\n",buffer);  
   
   return 0;  
 }  

 $ gcc lseek.c  
 $ cat testfile.txt   
 This is a test file that will be used  
 to demonstrate the use of lseek.  
 $ ./a.out   
 This is a test file   
 test file that will  

 #include <unistd.h>  
 #include <sys/stat.h>  
 #include <sys/types.h>  
 int fstat(int fildes, struct stat *buf);  
 int stat(const char *path, struct stat *buf);  
 int lstat(const char *path, struct stat *buf);  

 #include <unistd.h>  
 #include <stdio.h>  
 #include <sys/stat.h>  
 #include <sys/types.h>  
   
 int main(int argc, char **argv)  
 {  
   if(argc != 2)  
     return 1;  
   
   struct stat fileStat;  
   if(stat(argv[1],&fileStat) < 0)  
     return 1;  
   
   printf("Information for %s\n",argv[1]);  
   printf("---------------------------\n");  
   printf("File Size: \t\t%d bytes\n",fileStat.st_size);  
   printf("Number of Links: \t%d\n",fileStat.st_nlink);  
   printf("File inode: \t\t%d\n",fileStat.st_ino);  
   
   printf("File Permissions: \t");  
   printf( (S_ISDIR(fileStat.st_mode)) ? "d" : "-");  
   printf( (fileStat.st_mode & S_IRUSR) ? "r" : "-");  
   printf( (fileStat.st_mode & S_IWUSR) ? "w" : "-");  
   printf( (fileStat.st_mode & S_IXUSR) ? "x" : "-");  
   printf( (fileStat.st_mode & S_IRGRP) ? "r" : "-");  
   printf( (fileStat.st_mode & S_IWGRP) ? "w" : "-");  
   printf( (fileStat.st_mode & S_IXGRP) ? "x" : "-");  
   printf( (fileStat.st_mode & S_IROTH) ? "r" : "-");  
   printf( (fileStat.st_mode & S_IWOTH) ? "w" : "-");  
   printf( (fileStat.st_mode & S_IXOTH) ? "x" : "-");  
   printf("\n\n");  
   
   printf("The file %s a symbolic link\n", (S_ISLNK(fileStat.st_mode)) ? "is" : "is not");  
   
   return 0;  
 }  
   

 $ gcc stat.c   
 $ ./a.out stat.c   
 Information for stat.c  
 ---------------------------  
 File Size:           1209 bytes  
 Number of Links:      1  
 File inode:           3039505  
 File Permissions:      -rw-rw-r--  
   
 The file is not a symbolic link  
   

 #include <unistd.h>  
 int dup(int fildes);  
 int dup2(int fildes, int fildes2);  

 #include <unistd.h> /*Included for dup(2) and write(2)*/  
 #include <stdlib.h> /*Included for exit(3)*/  
   
 #define MESSAGE "Hey! Who redirected me?\r\n\0"  
   
 int main() {  
   int newfd = dup(1); /*Call dup for an aliased fd*/  
   char buff[] = MESSAGE;  
   
   if (newfd < 0) { /*Negative file descriptors are errors*/  
     exit(EXIT_FAILURE);  
   }  
   else if (write(newfd, buff, sizeof(buff)) < 0) { /*See: man 2 write*/  
     exit(EXIT_FAILURE);  
   }  
   
   return EXIT_SUCCESS;  
 }  
   

 $ gcc dup.c   
 $ ./a.out   
 Hey! Who redirected me?  
   

 #include <stdio.h>  
 #include <unistd.h>  
 #include <fcntl.h>  
   
   
 int main()  
 {  
   //First, we're going to open a file  
   int file = open("testfile.txt", O_APPEND | O_WRONLY);  
   if(file < 0)  return 1;  
   
   //Now we redirect standard output to the file using dup2  
   if(dup2(file, 1) < 0)  return 1;  
   
   //Now standard out has been redirected,  
   //we can write to the file  
   printf("This will print in testfile.txt\n");  
   
   return 0;  
 }//end of function main  
   

 $ gcc dup2.c   
 $ cat testfile.txt   
 Hello, I am a testfile.txt  
 $ ./a.out   
 $ cat testfile.txt   
 Hello, I am a testfile.txt  
 This will print in myfile.txt  
 $ ./a.out   
 $ cat testfile.txt   
 Hello, I am a testfile.txt  
 This will print in myfile.txt  
 This will print in myfile.txt