Assignment No-2

 //Assignment No-2

Set A:

Write a C program that behaves like a shell which displays the command prompt ‘myshell$’. It accepts the command, tokenize the command line and execute it by creating the child process. Also implement the additional command ‘count’ as 

⇛ myshell$ count c filename: It will display the number of characters in given file 

⇛ myshell$ count w filename: It will display the number of words in given file 

⇛ myshell$ count l filename: It will display the number of lines in given file.

CODE:

👇 

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
4. #include <unistd.h>
5. #include <sys/types.h>
6. #include <wait.h>
7. char comm[100],*ptr;
8. char *args[10];
9. int tot;
10. 
    
11. int count(char *option, char *fname);
12. void getcomm();
13. void sep_arg();
14. void take_action();
15. void main()
16. {
17. do
18. {
19. printf("\nCodingLab");
20. getcomm();
21. sep_arg();
22. take_action();
23. } while(1);
24. }
25. 
    
26. void sep_arg()
27. {
28. int i, j;
29. char *token;
30. i = j = tot = 0;
31. token = strtok(comm," ");
32. while(token != NULL)
33. {
34. args[tot] = (char*)malloc(20);
35. strcpy(args[tot++],token);
36. token=strtok(NULL," ");
37. }
38. return;
39. }
40. 
    
41. void getcomm()
42. {
43. int len;
44. ptr = fgets(comm,80,stdin);
45. len = strlen(comm);
46. comm[len-1] = "\0";
47. return;
48. }
49. 
    
50. void take_action()
51. {
52. char str[100];
53. pid_t pid;
54. int status;
55. 
    
56. ptr = comm;
57. if(ptr == NULL)
58. exit(0);
59. if(strlen(comm) <= 1)
60. return;
61. if(strcmp(args[0],"count") == 0)
62. count(args[1],args[2]);
63. else
64. if(pid = fork() < 0)
65. {
66. printf("\nUnable to create process");
67. }
68. else
69. if(pid == 0)//child
70. {
71. execvp(args[0],args);
72. strcpy(str,"./");
73. strcat(str,args[0]);
74. execvp(str,args);
75. printf("\n%s: Command Not Found ");
76. exit(0);
77. }
78. else
79. waitpid(pid,&status,0);
80. }
81. 
    
82. int count(char *option, char *fname)
83. {
84. int ccnt,wcnt,lcnt;
85. int ch;
86. FILE *fp;
87. int i;
88. fp = fopen(fname,"r");
89. if(fp==NULL)
90. {
91. printf("\nUnable to open file");
92. exit(0);
93. }
94. ccnt=wcnt=lcnt=0;
95. ch = fgetc(fp);
96. while(ch != EOF)
97. {
98. ccnt++;
99. if(ch == '' || ch == '\t')
100. {
101. wcnt++;
102. }
103. else
104. if(ch == '\n')
105. {
106. lcnt++;
107. wcnt++;
108. }
109. ch = fgetc(fp);
110. }
111. fclose(fp);
112. if(strcmp(option,"c") == 0)
113. {
114. printf("\nTotal chars in the file:\t%d",ccnt);
115. }
116. else
117. if(strcmp(option,"w") == 0)
118. {
119. printf("\nTotal words in the file:\t%d",wcnt);
120. }
121. else
122. if(strcmp(option,"l") == 0)
123. {
124. printf("\nTotal lines in the file:\t%d",lcnt);
125. }
126. else
127. printf("\nInvalid Option");
128. }

//Execute

/*Output

*/

Set B:

Write a C program that behaves like a shell which displays the command prompt ‘myshell$’. It accepts the command, tokenize the command line and execute it by creating the child process. Also implement the additional command ‘list’ as 

⇛ myshell$ list f dirname: It will display filenames in a given directory.

 

⇛ myshell$ list n dirname: It will count the number of entries in a given directory. 

⇛ myshell$ list i dirname: It will display filenames and their inode number for the files in a given directory.

CODE:

👇

1. #include <stdio.h>
2. #include <string.h>
3. #include <stdlib.h>
4. #include <unistd.h>
5. #include <sys/types.h>
6. #include <wait.h>
7. #include <dirent.h>
8. //Programs for create own shell
9. char comm[100],*ptr;
10. char *args[10];
11. int tot;
12. 
    
13. //function declear 
14. void list(char *option, char *dirname);
15. void getcomm();
16. void sep_arg();
17. void take_action();
18. 
    
19. void main()//main fuction
20. {
21. do
22. {
23. printf("\nCodingLab$");//enter which name you want to give shell
24. getcomm();
25. sep_arg();
26. take_action();
27. }while(1);
28. }
29. 
    
30. void sep_arg()
31. {
32. int i, j;
33. char *token;
34. i = j = tot =0;
36. token = strtok(comm," ");
37. while(token != NULL)
38. {
39. args[tot] = (char*)malloc(20);
40. strcpy(args[tot++],token);
41. token = strtok(NULL, " ");
42. }
43. for(i=0; i<tot; i++)
44. {
45. printf("%s",args[i]);
46. }
47. return;
48. }
49. void getcomm()
50. {
51. int len;
52. ptr = fgets(comm, 80,stdin);
53. len = strlen(comm);
54. comm[len-1] = '\0';
55. return;
56. }
57. 
    
58. void take_action()
59. {
60. char  str[100];
61. pid_t  pid;
62. int status;
63. 
    
64. ptr = comm;
65. if(ptr == NULL)
66. exit(0);
67. if( strlen(comm) <= 1)
68. return;
69. if(strcmp(args[0],"list") == 0)
70. list(args[1],args[2]);
71. else
72. if((pid = fork() < 0))
73. {
74. printf("\n Unable to create process");
75. }
76. else
77. if(pid == 0)//child
78. {
79. execvp(args[0],args);
80. strcpy(str,"./");
81. strcat(str,args[0]);
82. execvp(str,args);
83. printf("\n%s: Command not found", comm);
84. exit(0);
85. }
86. else
87. waitpid(pid,&status,0);
88. }
89. 
    
90. void list(char *option, char *dirname)
91. {
92. DIR *dp;
93. struct dirent *dent;
94. int cnt;
95. if(strcmp(option, "-f")==0)
96. {
97. //list all  dir entries
98. dp = opendir(dirname);
99. if(dp == NULL)
100. {
101. printf("\nUnable to open directory\n");
102. exit(0);
103. }
104. dent = readdir(dp);
105. while(dent != NULL)
106. {
107. printf("\n%s", dent->d_name);
108. dent = readdir(dp);
109. }
110. printf("\n");
111. }
112. else
113. if(strcmp(option, "-n")==0)
114. {
115. //list number all dir entries
116. cnt = 0;
117. dp = opendir(dirname);
118. if(dp == NULL)
119. {
120. printf("\nUnable to open dir");
121. exit(0);
122. }
123. dent = readdir(dp);
124. while(dent != NULL)
125. {
126. cnt++;
127. dent = readdir(dp);
128. }
129. printf("\nTotal dir entries :\t %d\n",cnt);
130. closedir(dp);
131. }
132. else
133. if(strcmp(option, "-i")==0)
134. {
135. //list all dir entries with inode
136. dp = opendir(dirname);
137. if(dp == NULL)
138. {
139. printf("\nUnable to open dir");
140. exit(0);
141. }
142. dent = readdir(dp);
143. while(dent != NULL)
144. {
145. printf("\n%s %ld",dent->d_name,dent->d_ino);
146. dent = readdir(dp);
147. }
148. printf("\n");
149. closedir(dp);
150. }
151. else
152. printf("\n>>Invalid Option<<\n");
153. }

Set C: 

1) Write a C program that behaves like a shell which displays the command prompt ‘myshell$’. It accepts the command, tokenize the command line and execute it by creating the child process. Also implement the additional command ‘typeline’ as 

⇛myshell$ typeline n filename: It will display first n lines of the file. 

⇛myshell$ typeline -n filename: It will display last n lines of the file. 

⇛myshell$ typeline a filename: It will display all the lines of the file.

CODE:

👇

1. #include <stdio.h>
2. #include <string.h>
3. #include <stdlib.h>
4. #include <unistd.h>
5. #include <sys/types.h>
6. #include <wait.h>
7. //Programs for create own shell
8. char comm[100],*ptr;
9. char *args[10];
10. int tot;
11. 
    
12. //function declear 
13. void typeline(char *option, char *fname);
14. void getcomm();
15. void sep_arg();
16. void take_action();
17. 
    
18. void main()//main fuction
19. {
20. do
21. {
22. printf("\nCodingLab$");//enter which name you want to give shell
23. getcomm();
24. sep_arg();
25. take_action();
26. }while(1);
27. }
28. 
    
29. void sep_arg()
30. {
31. int i, j;
32. char *token;
33. i = j = tot =0;
35. token = strtok(comm," ");
36. while(token != NULL)
37. {
38. args[tot] = (char*)malloc(20);
39. strcpy(args[tot++],token);
40. token = strtok(NULL, " ");
41. }
42. for(i=0; i<tot; i++)
43. {
44. printf("%s",args[i]);
45. }
46. return;
47. }
48. void getcomm()
49. {
50. int len;
51. ptr = fgets(comm, 80,stdin);
52. len = strlen(comm);
53. comm[len-1] = '\0';
54. return;
55. }
56. 
    
57. void take_action()
58. {
59. char  str[100];
60. pid_t  pid;
61. int status;
62. 
    
63. ptr = comm;
64. if(ptr == NULL)
65. exit(0);
66. if( strlen(comm) <= 1)
67. return;
68. if(strcmp(args[0],"typeline") == 0)
69. typeline(args[1],args[2]);
70. else
71. if((pid = fork() < 0))
72. {
73. printf("\n Unable to create process");
74. }
75. else
76. if(pid == 0)//child
77. {
78. execvp(args[0],args);
79. strcpy(str,"./");
80. strcat(str,args[0]);
81. execvp(str,args);
82. printf("\n%s: Command not found", comm);
83. exit(0);
84. }
85. else
86. waitpid(pid,&status,0);
87. }
88. 
    
89. void typeline(char *option, char *fname)
90. {
91. FILE *fp;
92. char str[80];
93. int tot_lines,ch,n,cnt;
94. //count the lines file
95. fp = fopen(fname, "r");
96. if(fp == NULL)
97. {
98. printf("\nUnable to Open file");
99. return;
100. }
101. tot_lines = 0;
102. while(!feof(fp))
103. {
104. fgets(str,80,fp);
105. tot_lines++;
106. }
107. fclose(fp);
108. if(strcmp(option, "a")==0)
109. {
110. fp=fopen(fname,"r");
111. while(!feof(fp))
112. {
113. fgets(str,80,fp);
114. if(feof(fp))
115. break;
116. printf("%s",str);
117. }
118. fclose(fp);
119. }
120. else
121. if(option[0]== '+')//print first n line
122. {
123. n = atol(option+1);
124. if(n > tot_lines)
125. {
126. printf("\ninvalid number of lines");
127. return;
128. }
129. fp=fopen(fname,"r");
130. cnt = 0;
131. while(cnt < n)
132. {
133. fgets(str,80,fp); if(feof(fp)) break;
134. printf("%s",str);
135. cnt++;
136. }
137. fclose(fp);
138. }
139. else
140. if(option[0]== '-')//print last n lines
141. {
142. n = atoi(option+1);
143. if(n > tot_lines)
144. {
145. printf("\ninvalid number of lines");
146. return;
147. }
148. fp = fopen(fname,"r");
149. cnt = 0;
150. while(cnt < tot_lines - n)
151. {
152. fgets(str,80,fp); if(feof(fp)) break;
153. cnt++;
154. }
155. while(!feof(fp))
156. {
157. fgets(str,80,fp); if(feof(fp)) break;
158. printf("%s",str);
159. cnt++;
160. }
161. fclose(fp);
162. }
163. else
164. printf("\nInvalid options");
165. }

2) Write a C program that behaves like a shell which displays the command prompt ‘myshell$’. It accepts the command, tokenize the command line and execute it by creating the child process. Also implement the additional command ‘search’ as 

⇛myshell$ search f filename pattern : It will search the first occurrence of pattern in the given file.

⇛myshell$ search a filename pattern : It will search all the occurrence of pattern in the given file.

⇛myshell$ search c filename pattern : It will count the number of occurrence of pattern in the given file.

CODE:

👇

1. #include <stdio.h>
2. #include <string.h>
3. #include <stdlib.h>
4. #include <unistd.h>
5. #include <sys/types.h>
6. #include <wait.h>
7. //Programs for create own shell
8. char comm[100],*ptr;
9. char *args[10];
10. int tot;
11. 
    
12. //function declear 
13. void search(char *option, char *pattern, char *fname);
14. void getcomm();
15. void sep_arg();
16. void take_action();
17. 
    
18. void main()//main fuction
19. {
20. do
21. {
22. printf("\nCodingLab$");//enter which name you want to give shell
23. getcomm();
24. sep_arg();
25. take_action();
26. }while(1);
27. }
28. 
    
29. void sep_arg()
30. {
31. int i, j;
32. char *token;
33. i = j = tot =0;
35. args[tot] = (char*)malloc(sizeof(char)*20);
36. for(i=0; comm[i] != '\0'; i++)
37. {
38. if(comm[i] == ' ')
39. {
40. args[tot][j] = '\0';
41. tot++;
42. args[tot] = (char*)malloc(sizeof(char)*20);
43. j=0;
44. }
45. else
46. {
47. args[tot][j] = comm[i];
48. j++;
49. }
50. }//for
51. args[tot][j] = '\0';
52. return;
53. }
54. void getcomm()
55. {
56. int len;
57. ptr = fgets(comm, 80,stdin);
58. len = strlen(comm);
59. comm[len-1] = '\0';
60. return;
61. }
62. 
    
63. void take_action()
64. {
65. char  str[100];
66. pid_t  pid;
67. int status;
68. 
    
69. ptr = comm;
70. if(ptr == NULL)
71. exit(0);
72. if( strlen(comm) <= 1)
73. return;
74. if(strcmp(args[0],"search") == 0)
75. search(args[1],args[2],args[3]);
76. else
77. if((pid = fork() < 0))
78. {
79. printf("\n Unable to create process");
80. }
81. else
82. if(pid == 0)//child
83. {
84. execvp(args[0],args);
85. strcpy(str,"./");
86. strcat(str,args[0]);
87. execvp(str,args);
88. printf("\n%s: Command not found", comm);
89. exit(0);
90. }
91. else
92. waitpid(pid,&status,0);
93. }
94. 
    
95. void search(char *option, char *pattern, char *fname)
96. {
97. char buff[100], *ptr;
98. int cnt;
99. FILE *fp;
100. int i;
101. fp = fopen(fname, "r");
102. if(fp == NULL)
103. {
104. printf("\nUnable to open file");
105. exit(0);
106. }
107. switch(option[0])
108. {
109. case 'a' :
110. while(!feof(fp))
111. {
112. buff[0] = '\0';
113. fgets(buff,80,fp);
114. ptr = strstr(buff,pattern);
115. if(ptr != NULL)
116. printf("%s", buff);
117. }
118. fclose(fp);
119. break;
120. case 'c' :
121. cnt = 0;
122. buff[0] = '\0';
123. fgets(buff,80,fp);
124. ptr = strstr(buff,pattern);
125. while(ptr != NULL)
126. {
127. cnt++;
128. ptr = ptr + strlen(pattern);
129. ptr = strstr(ptr, pattern);
130. }
131. fclose(fp);
132. printf("\nThe search %s occurs %d times ",pattern ,cnt);
133. break;
134. case 'f' :
135. while(!feof(fp))
136. {
137. buff[0] = '\0';
138. fgets(buff,80,fp);
139. ptr = strstr(buff,pattern);
140. if(ptr != NULL)
141. {
142. printf("%s", buff);
143. break;
144. }
145. }
146. fclose(fp);
147. break;
148. }
149. return;
150. }

//

/*Output

*/