Merge commit '557bfce07db8d643e262348f394fb07c1dca6954' into update-subtrees

masatake · masatake · commit 0e675dcc44e6 · 2021-09-16T07:35:24.000+09:00
diff --git a/libreadtags/.circleci/config.yml b/libreadtags/.circleci/config.yml
@@ -23,7 +23,7 @@ jobs:
       - run:
           name: Test
           command: |
-            make check
+            make check VERBOSE=1
   fedora31_distcheck:
     working_directory: ~/libreadtags
     docker:
diff --git a/libreadtags/.gitignore b/libreadtags/.gitignore
@@ -31,9 +31,11 @@ test-driver
 
 tests/*.log
 tests/*.trs
+tests/test-api-tagsClose
 tests/test-api-tagsFind
 tests/test-api-tagsFirst
 tests/test-api-tagsFirstPseudoTag
 tests/test-api-tagsOpen
+tests/test-api-tagsSetSortType
 tests/test-fix-null-deref
 tests/test-fix-unescaping
diff --git a/libreadtags/NEWS.md b/libreadtags/NEWS.md
@@ -1,3 +1,11 @@
+# Version ???
+
+- delete debug output automatically printed when DEBUG is defiend in
+  build-time.
+
+- fix potential crashes trigged when passing NULL as `file` parameter
+  to the API functions. Provided by rootkea (GitHub account).
+
 # Version 0.1.0
 
 - propagate internal errors to caller
diff --git a/libreadtags/autogen.sh b/libreadtags/autogen.sh
diff --git a/libreadtags/readtags.c b/libreadtags/readtags.c
@@ -870,19 +870,23 @@ static void terminate (tagFile *const file)
 static tagResult readNext (tagFile *const file, tagEntry *const entry)
 {
 	tagResult result;
-	if (file == NULL  ||  ! file->initialized)
+
+	if (file == NULL)
+		return TagFailure;
+
+	if (! file->initialized)
 	{
 		file->err = TagErrnoInvalidArgument;
-		result = TagFailure;
-	}
-	else if (! readTagLine (file, &file->err))
-		result = TagFailure;
-	else
-	{
-		result = (entry != NULL)
-			? parseTagLine (file, entry, &file->err)
-			: TagSuccess;
+		return TagFailure;
 	}
+
+	if (! readTagLine (file, &file->err))
+		return TagFailure;
+
+	result = (entry != NULL)
+		? parseTagLine (file, entry, &file->err)
+		: TagSuccess;
+
 	return result;
 }
 
@@ -1034,7 +1038,10 @@ static tagResult findSequentialFull (tagFile *const file,
 									 int (* isAcceptable) (tagFile *const, void *),
 									 void *data)
 {
-	if (file == NULL || !file->initialized || file->err)
+	if (file == NULL)
+		return TagFailure;
+
+	if (!file->initialized || file->err)
 	{
 		file->err = TagErrnoInvalidArgument;
 		return TagFailure;
@@ -1095,18 +1102,12 @@ static tagResult find (tagFile *const file, tagEntry *const entry,
 	if ((file->sortMethod == TAG_SORTED      && !file->search.ignorecase) ||
 		(file->sortMethod == TAG_FOLDSORTED  &&  file->search.ignorecase))
 	{
-#ifdef DEBUG
-		fputs ("<performing binary search>\n", stderr);
-#endif
 		result = findBinary (file);
 		if (result == TagFailure && file->err)
 			return TagFailure;
 	}
 	else
 	{
-#ifdef DEBUG
-		fputs ("<performing sequential search>\n", stderr);
-#endif
 		result = findSequential (file);
 		if (result == TagFailure && file->err)
 			return TagFailure;
@@ -1155,9 +1156,12 @@ static tagResult findNext (tagFile *const file, tagEntry *const entry)
 
 static tagResult findPseudoTag (tagFile *const file, int rewindBeforeFinding, tagEntry *const entry)
 {
-	if (file == NULL || (!file->initialized) || file->err)
+	if (file == NULL)
+		return TagFailure;
+
+	if (!file->initialized || file->err)
 	{
-		file->err= TagErrnoInvalidArgument;;
+		file->err = TagErrnoInvalidArgument;
 		return TagFailure;
 	}
 
@@ -1188,7 +1192,10 @@ extern tagFile *tagsOpen (const char *const filePath, tagFileInfo *const info)
 
 extern tagResult tagsSetSortType (tagFile *const file, const tagSortType type)
 {
-	if (file == NULL || (!file->initialized) || file->err)
+	if (file == NULL)
+		return TagFailure;
+
+	if (!file->initialized || file->err)
 	{
 		file->err = TagErrnoInvalidArgument;
 		return TagFailure;
@@ -1209,7 +1216,10 @@ extern tagResult tagsSetSortType (tagFile *const file, const tagSortType type)
 
 extern tagResult tagsFirst (tagFile *const file, tagEntry *const entry)
 {
-	if (file == NULL || (!file->initialized) || file->err)
+	if (file == NULL)
+		return TagFailure;
+
+	if (!file->initialized || file->err)
 	{
 		file->err = TagErrnoInvalidArgument;
 		return TagFailure;
@@ -1222,7 +1232,10 @@ extern tagResult tagsFirst (tagFile *const file, tagEntry *const entry)
 
 extern tagResult tagsNext (tagFile *const file, tagEntry *const entry)
 {
-	if (file == NULL || (!file->initialized) || file->err)
+	if (file == NULL)
+		return TagFailure;
+
+	if (!file->initialized || file->err)
 	{
 		file->err = TagErrnoInvalidArgument;
 		return TagFailure;
@@ -1242,21 +1255,29 @@ extern const char *tagsField (const tagEntry *const entry, const char *const key
 extern tagResult tagsFind (tagFile *const file, tagEntry *const entry,
 						   const char *const name, const int options)
 {
-	if (file == NULL || !file->initialized || file->err)
+	if (file == NULL)
+		return TagFailure;
+
+	if (!file->initialized || file->err)
 	{
 		file->err = TagErrnoInvalidArgument;
 		return TagFailure;
 	}
+
 	return find (file, entry, name, options);
 }
 
 extern tagResult tagsFindNext (tagFile *const file, tagEntry *const entry)
 {
-	if (file == NULL || !file->initialized || file->err)
+	if (file == NULL)
+		return TagFailure;
+
+	if (!file->initialized || file->err)
 	{
 		file->err = TagErrnoInvalidArgument;
 		return TagFailure;
 	}
+
 	return findNext (file, entry);
 }
 
diff --git a/libreadtags/tests/test-api-tagsFind.c b/libreadtags/tests/test-api-tagsFind.c
@@ -65,14 +65,14 @@ check_finding0 (tagFile *t, const char *name, const int options,
 				if (err == x->err)
 				{
 					if (err == 0)
-						fprintf (stderr, "not found, and it is expected\n", err);
+						fprintf (stderr, "not found, and it is expected\n");
 					else
 						fprintf (stderr, "error as expected: %d\n", err);
 					continue;
 				}
 				else
 				{
-					fprintf (stderr, "errer number doesn't match: %d (expected: %d)\n",
+					fprintf (stderr, "error number doesn't match: %d (expected: %d)\n",
 							 err, x->err);
 					return 1;
 				}
diff --git a/libreadtags/tests/test-api-tagsOpen.c b/libreadtags/tests/test-api-tagsOpen.c
@@ -157,7 +157,8 @@ main (void)
 	}
 	fprintf (stderr, "ok\n");
 
-	fprintf (stderr, "opening a / (EISDIR is expected)...");
+	fprintf (stderr, "opening a / (an error is expected)...");
+	info.status.error_number = 0;
 	t = tagsOpen ("/", &info);
 	if (t != NULL)
 	{
@@ -169,12 +170,12 @@ main (void)
 		fprintf (stderr, "unexpected result (opened != 0)\n");
 		return 1;
 	}
-	else if (info.status.error_number != EISDIR)
+	else if (info.status.error_number == 0)
 	{
-		fprintf (stderr, "unexpected result (error_number != EISDIR)\n");
+		fprintf (stderr, "no error\n");
 		return 1;
 	}
-	fprintf (stderr, "ok\n");
+	fprintf (stderr, "ok (errno: %d)\n", info.status.error_number);
 
 	fprintf (stderr, "closing the unopened tag file...");
 	if (tagsClose (t) == TagSuccess)
@@ -275,9 +276,9 @@ main (void)
 	for (int i = 0; i < 6; i++)
 	{
 		char tagf_name_tmpl [] = "./api-tagsOpen-incomplete-program-author-%d.tags";
-		char tagf_name [sizeof (tagf_name_tmpl)];
+		char tagf_name [sizeof (tagf_name_tmpl) - 1];
 		fprintf (stderr, "opening a tags file with incomplete PROGRAM_AUTHOR field [trimming level: %d]...", i);
-		sprintf (tagf_name, tagf_name_tmpl, i);
+		snprintf (tagf_name, sizeof (tagf_name), tagf_name_tmpl, i);
 		t = tagsOpen (tagf_name, &info);
 		if (t == NULL)
 		{
diff --git a/libreadtags/tests/test-fix-null-deref.c b/libreadtags/tests/test-fix-null-deref.c
@@ -41,7 +41,6 @@ main (void)
 	fprintf (stderr, "ok\n");
 
 	tagEntry e;
-	tagResult r;
 
 	/* Without fix, this program crashes in tagsFirst(). */
 	tagsFirst (t, &e);

Original file line number	Diff line number	Diff line change
`@@ -870,19 +870,23 @@ static void terminate (tagFile *const file)`
`870`	`870`	`static tagResult readNext (tagFile const file, tagEntry const entry)`
`871`	`871`	`{`
`872`	`872`	`tagResult result;`
`873`		`- if (file == NULL \|\| ! file->initialized)`
	`873`	`+`
	`874`	`+ if (file == NULL)`
	`875`	`+ return TagFailure;`
	`876`	`+`
	`877`	`+ if (! file->initialized)`
`874`	`878`	`{`
`875`	`879`	`file->err = TagErrnoInvalidArgument;`
`876`		`- result = TagFailure;`
`877`		`- }`
`878`		`- else if (! readTagLine (file, &file->err))`
`879`		`- result = TagFailure;`
`880`		`- else`
`881`		`- {`
`882`		`- result = (entry != NULL)`
`883`		`- ? parseTagLine (file, entry, &file->err)`
`884`		`- : TagSuccess;`
	`880`	`+ return TagFailure;`
`885`	`881`	`}`
	`882`	`+`
	`883`	`+ if (! readTagLine (file, &file->err))`
	`884`	`+ return TagFailure;`
	`885`	`+`
	`886`	`+ result = (entry != NULL)`
	`887`	`+ ? parseTagLine (file, entry, &file->err)`
	`888`	`+ : TagSuccess;`
	`889`	`+`
`886`	`890`	`return result;`
`887`	`891`	`}`
`888`	`892`
`@@ -1034,7 +1038,10 @@ static tagResult findSequentialFull (tagFile *const file,`
`1034`	`1038`	`int (* isAcceptable) (tagFile const, void ),`
`1035`	`1039`	`void *data)`
`1036`	`1040`	`{`
`1037`		`- if (file == NULL \|\| !file->initialized \|\| file->err)`
	`1041`	`+ if (file == NULL)`
	`1042`	`+ return TagFailure;`
	`1043`	`+`
	`1044`	`+ if (!file->initialized \|\| file->err)`
`1038`	`1045`	`{`
`1039`	`1046`	`file->err = TagErrnoInvalidArgument;`
`1040`	`1047`	`return TagFailure;`
`@@ -1095,18 +1102,12 @@ static tagResult find (tagFile const file, tagEntry const entry,`
`1095`	`1102`	`if ((file->sortMethod == TAG_SORTED && !file->search.ignorecase) \|\|`
`1096`	`1103`	`(file->sortMethod == TAG_FOLDSORTED && file->search.ignorecase))`
`1097`	`1104`	`{`
`1098`		`-#ifdef DEBUG`
`1099`		`- fputs ("<performing binary search>\n", stderr);`
`1100`		`-#endif`
`1101`	`1105`	`result = findBinary (file);`
`1102`	`1106`	`if (result == TagFailure && file->err)`
`1103`	`1107`	`return TagFailure;`
`1104`	`1108`	`}`
`1105`	`1109`	`else`
`1106`	`1110`	`{`
`1107`		`-#ifdef DEBUG`
`1108`		`- fputs ("<performing sequential search>\n", stderr);`
`1109`		`-#endif`
`1110`	`1111`	`result = findSequential (file);`
`1111`	`1112`	`if (result == TagFailure && file->err)`
`1112`	`1113`	`return TagFailure;`
`@@ -1155,9 +1156,12 @@ static tagResult findNext (tagFile const file, tagEntry const entry)`
`1155`	`1156`
`1156`	`1157`	`static tagResult findPseudoTag (tagFile const file, int rewindBeforeFinding, tagEntry const entry)`
`1157`	`1158`	`{`
`1158`		`- if (file == NULL \|\| (!file->initialized) \|\| file->err)`
	`1159`	`+ if (file == NULL)`
	`1160`	`+ return TagFailure;`
	`1161`	`+`
	`1162`	`+ if (!file->initialized \|\| file->err)`
`1159`	`1163`	`{`
`1160`		`- file->err= TagErrnoInvalidArgument;;`
	`1164`	`+ file->err = TagErrnoInvalidArgument;`
`1161`	`1165`	`return TagFailure;`
`1162`	`1166`	`}`
`1163`	`1167`
`@@ -1188,7 +1192,10 @@ extern tagFile tagsOpen (const char const filePath, tagFileInfo *const info)`
`1188`	`1192`
`1189`	`1193`	`extern tagResult tagsSetSortType (tagFile *const file, const tagSortType type)`
`1190`	`1194`	`{`
`1191`		`- if (file == NULL \|\| (!file->initialized) \|\| file->err)`
	`1195`	`+ if (file == NULL)`
	`1196`	`+ return TagFailure;`
	`1197`	`+`
	`1198`	`+ if (!file->initialized \|\| file->err)`
`1192`	`1199`	`{`
`1193`	`1200`	`file->err = TagErrnoInvalidArgument;`
`1194`	`1201`	`return TagFailure;`
`@@ -1209,7 +1216,10 @@ extern tagResult tagsSetSortType (tagFile *const file, const tagSortType type)`
`1209`	`1216`
`1210`	`1217`	`extern tagResult tagsFirst (tagFile const file, tagEntry const entry)`
`1211`	`1218`	`{`
`1212`		`- if (file == NULL \|\| (!file->initialized) \|\| file->err)`
	`1219`	`+ if (file == NULL)`
	`1220`	`+ return TagFailure;`
	`1221`	`+`
	`1222`	`+ if (!file->initialized \|\| file->err)`
`1213`	`1223`	`{`
`1214`	`1224`	`file->err = TagErrnoInvalidArgument;`
`1215`	`1225`	`return TagFailure;`
`@@ -1222,7 +1232,10 @@ extern tagResult tagsFirst (tagFile const file, tagEntry const entry)`
`1222`	`1232`
`1223`	`1233`	`extern tagResult tagsNext (tagFile const file, tagEntry const entry)`
`1224`	`1234`	`{`
`1225`		`- if (file == NULL \|\| (!file->initialized) \|\| file->err)`
	`1235`	`+ if (file == NULL)`
	`1236`	`+ return TagFailure;`
	`1237`	`+`
	`1238`	`+ if (!file->initialized \|\| file->err)`
`1226`	`1239`	`{`
`1227`	`1240`	`file->err = TagErrnoInvalidArgument;`
`1228`	`1241`	`return TagFailure;`
`@@ -1242,21 +1255,29 @@ extern const char tagsField (const tagEntry const entry, const char *const key`
`1242`	`1255`	`extern tagResult tagsFind (tagFile const file, tagEntry const entry,`
`1243`	`1256`	`const char *const name, const int options)`
`1244`	`1257`	`{`
`1245`		`- if (file == NULL \|\| !file->initialized \|\| file->err)`
	`1258`	`+ if (file == NULL)`
	`1259`	`+ return TagFailure;`
	`1260`	`+`
	`1261`	`+ if (!file->initialized \|\| file->err)`
`1246`	`1262`	`{`
`1247`	`1263`	`file->err = TagErrnoInvalidArgument;`
`1248`	`1264`	`return TagFailure;`
`1249`	`1265`	`}`
	`1266`	`+`
`1250`	`1267`	`return find (file, entry, name, options);`
`1251`	`1268`	`}`
`1252`	`1269`
`1253`	`1270`	`extern tagResult tagsFindNext (tagFile const file, tagEntry const entry)`
`1254`	`1271`	`{`
`1255`		`- if (file == NULL \|\| !file->initialized \|\| file->err)`
	`1272`	`+ if (file == NULL)`
	`1273`	`+ return TagFailure;`
	`1274`	`+`
	`1275`	`+ if (!file->initialized \|\| file->err)`
`1256`	`1276`	`{`
`1257`	`1277`	`file->err = TagErrnoInvalidArgument;`
`1258`	`1278`	`return TagFailure;`
`1259`	`1279`	`}`
	`1280`	`+`
`1260`	`1281`	`return findNext (file, entry);`
`1261`	`1282`	`}`
`1262`	`1283`
Original file line number	Diff line number	Diff line change
`@@ -65,14 +65,14 @@ check_finding0 (tagFile t, const char name, const int options,`
`65`	`65`	`if (err == x->err)`
`66`	`66`	`{`
`67`	`67`	`if (err == 0)`
`68`		`- fprintf (stderr, "not found, and it is expected\n", err);`
	`68`	`+ fprintf (stderr, "not found, and it is expected\n");`
`69`	`69`	`else`
`70`	`70`	`fprintf (stderr, "error as expected: %d\n", err);`
`71`	`71`	`continue;`
`72`	`72`	`}`
`73`	`73`	`else`
`74`	`74`	`{`
`75`		`- fprintf (stderr, "errer number doesn't match: %d (expected: %d)\n",`
	`75`	`+ fprintf (stderr, "error number doesn't match: %d (expected: %d)\n",`
`76`	`76`	`err, x->err);`
`77`	`77`	`return 1;`
`78`	`78`	`}`
Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,8 @@ main (void)`
`157`	`157`	`}`
`158`	`158`	`fprintf (stderr, "ok\n");`
`159`	`159`
`160`		`- fprintf (stderr, "opening a / (EISDIR is expected)...");`
	`160`	`+ fprintf (stderr, "opening a / (an error is expected)...");`
	`161`	`+ info.status.error_number = 0;`
`161`	`162`	`t = tagsOpen ("/", &info);`
`162`	`163`	`if (t != NULL)`
`163`	`164`	`{`
`@@ -169,12 +170,12 @@ main (void)`
`169`	`170`	`fprintf (stderr, "unexpected result (opened != 0)\n");`
`170`	`171`	`return 1;`
`171`	`172`	`}`
`172`		`- else if (info.status.error_number != EISDIR)`
	`173`	`+ else if (info.status.error_number == 0)`
`173`	`174`	`{`
`174`		`- fprintf (stderr, "unexpected result (error_number != EISDIR)\n");`
	`175`	`+ fprintf (stderr, "no error\n");`
`175`	`176`	`return 1;`
`176`	`177`	`}`
`177`		`- fprintf (stderr, "ok\n");`
	`178`	`+ fprintf (stderr, "ok (errno: %d)\n", info.status.error_number);`
`178`	`179`
`179`	`180`	`fprintf (stderr, "closing the unopened tag file...");`
`180`	`181`	`if (tagsClose (t) == TagSuccess)`
`@@ -275,9 +276,9 @@ main (void)`
`275`	`276`	`for (int i = 0; i < 6; i++)`
`276`	`277`	`{`
`277`	`278`	`char tagf_name_tmpl [] = "./api-tagsOpen-incomplete-program-author-%d.tags";`
`278`		`- char tagf_name [sizeof (tagf_name_tmpl)];`
	`279`	`+ char tagf_name [sizeof (tagf_name_tmpl) - 1];`
`279`	`280`	`fprintf (stderr, "opening a tags file with incomplete PROGRAM_AUTHOR field [trimming level: %d]...", i);`
`280`		`- sprintf (tagf_name, tagf_name_tmpl, i);`
	`281`	`+ snprintf (tagf_name, sizeof (tagf_name), tagf_name_tmpl, i);`
`281`	`282`	`t = tagsOpen (tagf_name, &info);`
`282`	`283`	`if (t == NULL)`
`283`	`284`	`{`