[{"data":1,"prerenderedAt":4534},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr30-c":28,"surround-\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr30-c":2747,"sidebar-sei-cert-c-coding-standard":2755},[4,8],{"title":5,"path":6,"_path":6,"fromAppConfig":7},"Home","\u002F",true,{"title":9,"path":10,"children":11,"_path":27,"fromAppConfig":7},"Coding Standards","\u002Fcoding-standards\u002F",[12,15,18,21,24],{"title":13,"path":14},"Android Coding Standard","\u002Fandroid-secure-coding-standard\u002F",{"title":16,"path":17},"C Coding Standard","\u002Fsei-cert-c-coding-standard\u002F",{"title":19,"path":20},"C++ Coding Standard","\u002Fsei-cert-cpp-coding-standard\u002F",{"title":22,"path":23},"Java Coding Standard","\u002Fsei-cert-oracle-coding-standard-for-java\u002F",{"title":25,"path":26},"Perl Coding Standard","\u002Fsei-cert-perl-coding-standard\u002F","\u002Fcoding-standards",{"id":29,"title":30,"body":31,"description":2731,"extension":2732,"meta":2733,"navigation":7,"path":2743,"seo":2744,"stem":2745,"__hash__":2746},"content\u002F4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F2.err30-c.md","ERR30-C. Take care when reading errno",{"type":32,"value":33,"toc":2695},"minimark",[34,38,62,71,104,114,117,147,155,163,185,193,357,363,390,417,431,438,674,680,692,710,714,756,762,768,922,958,965,988,1200,1203,1209,1223,1375,1380,1392,1481,1486,1498,1576,1581,1590,1700,1706,1720,1802,1808,1814,1938,1942,1948,2008,2013,2420,2424,2438,2442,2449,2527,2531,2537,2541,2544,2547,2552,2556,2559,2562,2566,2648,2651,2671,2675,2691],[35,36,30],"h1",{"id":37},"err30-c-take-care-when-reading-errno",[39,40,41,42,46,47,49,50,52,53,55,56,58,59,61],"p",{},"The value of ",[43,44,45],"code",{},"errno"," is initialized to zero at program startup, but it is never subsequently set to zero by any C standard library function. The value of ",[43,48,45],{}," may be set to nonzero by a C standard library function call whether or not there is an error, provided the use of ",[43,51,45],{}," is not documented in the description of the function. It is meaningful for a program to inspect the contents of ",[43,54,45],{}," only after an error might have occurred. More precisely, ",[43,57,45],{}," is meaningful only after a library function that sets ",[43,60,45],{}," on error has returned an error code.",[39,63,64,65,70],{},"According to Question 20.4 of C-FAQ [ ",[66,67,69],"a",{"href":68},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-Summit05","Summit 2005"," ],",[72,73,74],"blockquote",{},[39,75,76,77,79,80,83,84,87,88,90,91,94,95,97,98,100,101,103],{},"In general, you should detect errors by checking return values, and use ",[43,78,45],{}," only to distinguish among the various causes of an error, such as \"File not found\" or \"Permission denied.\" (Typically, you use ",[43,81,82],{},"perror"," or ",[43,85,86],{},"strerror"," to print these discriminating error messages.) It's only necessary to detect errors with ",[43,89,45],{}," when a function does not have a unique, unambiguous, out-of-band error return (that is, because all of its possible return values are valid; one example is ",[43,92,93],{},"   atoi [         sic        ]  "," ). In these cases (and in these cases only; check the documentation to be sure whether a function allows this), you can detect errors by setting ",[43,96,45],{}," to 0, calling the function, and then testing ",[43,99,45],{}," . (Setting ",[43,102,45],{}," to 0 first is important, as no library function ever does that for you.)",[39,105,106,107,110,111,113],{},"Note that ",[43,108,109],{},"atoi()"," is not required to set the value of ",[43,112,45],{}," .",[39,115,116],{},"Library functions fall into the following categories:",[118,119,120,131,139,144],"ul",{},[121,122,123,124,126,127],"li",{},"Those that set ",[43,125,45],{}," and return an ",[66,128,130],{"href":129},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-out-of-banderrorindicator","out-of-band error indicator",[121,132,123,133,126,135],{},[43,134,45],{},[66,136,138],{"href":137},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-in-banderrorindicator","in-band error indicator",[121,140,141,142],{},"Those that do not promise to set ",[43,143,45],{},[121,145,146],{},"Those with differing standards documentation",[148,149,151,152,154],"h2",{"id":150},"library-functions-that-set-errno-and-return-an-out-of-band-error-indicator","Library Functions that Set ",[43,153,45],{}," and Return an Out-of-Band Error Indicator",[39,156,157,158,126,160,162],{},"The C Standard specifies that the functions listed in the following table set ",[43,159,45],{},[66,161,130],{"href":129}," . That is, their return value on error can never be returned by a successful call.",[39,164,165,166,168,169,171,172,174,175,178,179,181,182,113],{},"A program may check ",[43,167,45],{}," after invoking these library functions but is not required to do so. The program should not check the value of ",[43,170,45],{}," without first verifying that the function returned an error indicator. For example, ",[43,173,45],{}," should not be checked after calling ",[43,176,177],{},"signal()"," without first ensuring that ",[43,180,177],{}," actually returned ",[43,183,184],{},"SIG_ERR",[39,186,187],{},[188,189,190,191,154],"strong",{},"Functions That Set ",[43,192,45],{},[194,195,196,209],"table",{},[197,198,199],"thead",{},[200,201,202,205,207],"tr",{},[203,204],"th",{},[203,206],{},[203,208],{},[210,211,212,233,248,264,285,299,317,337],"tbody",{},[200,213,214,220,225],{},[215,216,217],"td",{},[188,218,219],{},"Function Name",[215,221,222],{},[188,223,224],{},"Return Value",[215,226,227,229,230],{},[43,228,45],{}," ",[188,231,232],{},"Value",[200,234,235,240,245],{},[215,236,237],{},[43,238,239],{},"ftell()",[215,241,242],{},[43,243,244],{},"-1L",[215,246,247],{},"Positive",[200,249,250,259,262],{},[215,251,252,255,256],{},[43,253,254],{},"fgetpos()"," , ",[43,257,258],{},"fsetpos()",[215,260,261],{},"Nonzero",[215,263,247],{},[200,265,266,275,280],{},[215,267,268,271,272],{},[43,269,270],{},"      mbrtowc       ()     ",",",[43,273,274],{},"      mbsrtowcs()     ",[215,276,277],{},[43,278,279],{},"      (size_t)(-1)     ",[215,281,282],{},[43,283,284],{},"      EILSEQ     ",[200,286,287,292,297],{},[215,288,289],{},[43,290,291],{},"      signal       ()     ",[215,293,294],{},[43,295,296],{},"      SIG_ERR     ",[215,298,247],{},[200,300,301,309,313],{},[215,302,303,271,306],{},[43,304,305],{},"      wcrtomb       ()     ",[43,307,308],{},"      wcsrtombs()     ",[215,310,311],{},[43,312,279],{},[215,314,315],{},[43,316,284],{},[200,318,319,327,332],{},[215,320,321,255,324],{},[43,322,323],{},"mbrtoc16()",[43,325,326],{},"mbrtoc32()",[215,328,329],{},[43,330,331],{},"(size_t)(-1)",[215,333,334],{},[43,335,336],{},"EILSEQ",[200,338,339,347,352],{},[215,340,341,255,344],{},[43,342,343],{},"c16rtomb()",[43,345,346],{},"     c32rtomb      ()    ",[215,348,349],{},[43,350,351],{},"     (size_t)(-1)    ",[215,353,354],{},[43,355,356],{},"     EILSEQ    ",[148,358,151,360,362],{"id":359},"library-functions-that-set-errno-and-return-an-in-band-error-indicator",[43,361,45],{}," and Return an In-Band Error Indicator",[39,364,157,365,126,367,369,370,373,374,377,378,380,381,384,385,387,388,113],{},[43,366,45],{},[66,368,138],{"href":137}," . That is, the return value when an error occurs is also a valid return value for successful calls. For example, the ",[43,371,372],{},"strtoul()"," function returns ",[43,375,376],{},"ULONG_MAX"," and sets ",[43,379,45],{}," to ",[43,382,383],{},"ERANGE"," if an error occurs. Because ",[43,386,376],{}," is a valid return value, the only way to confirm that an error occurred when LONG_MAX is returned is to check ",[43,389,45],{},[39,391,392,393,396,397,400,401,404,405,407,408,380,410,412,413,416],{},"The ",[43,394,395],{},"fgetwc()"," and ",[43,398,399],{},"fputwc()"," functions return ",[43,402,403],{},"WEOF"," in multiple cases, only one of which results in setting ",[43,406,45],{}," . The string conversion functions will return the maximum or minimum representable value and set ",[43,409,45],{},[43,411,383],{}," if the converted value cannot be represented by the data type. However, if the conversion cannot happen because the input is invalid, the function will return ",[43,414,415],{},"0"," , and the output pointer parameter will be assigned the value of the input pointer parameter, provided the output parameter is non-null.",[39,418,419,420,422,423,380,425,427,428,430],{},"A program that uses ",[43,421,45],{}," for error checking  a function that returns an in-band error indicator must set ",[43,424,45],{},[43,426,415],{}," before calling one of these library functions and then inspect ",[43,429,45],{}," before a subsequent library function call.",[39,432,433],{},[188,434,435,436,362],{},"Functions that Set ",[43,437,45],{},[194,439,440,450],{},[197,441,442],{},[200,443,444,446,448],{},[203,445],{},[203,447],{},[203,449],{},[210,451,452,468,484,508,530,549,568,587,609,630,652],{},[200,453,454,458,462],{},[215,455,456],{},[188,457,219],{},[215,459,460],{},[188,461,224],{},[215,463,464,229,466],{},[43,465,45],{},[188,467,232],{},[200,469,470,476,480],{},[215,471,472,255,474],{},[43,473,395],{},[43,475,399],{},[215,477,478],{},[43,479,403],{},[215,481,482],{},[43,483,336],{},[200,485,486,494,503],{},[215,487,488,271,491],{},[43,489,490],{},"      strtol       ()     ",[43,492,493],{},"      wcstol       ()     ",[215,495,496,499,500],{},[43,497,498],{},"      LONG_MIN     ","or",[43,501,502],{},"      LONG_MAX     ",[215,504,505],{},[43,506,507],{},"      ERANGE     ",[200,509,510,518,526],{},[215,511,512,271,515],{},[43,513,514],{},"      strtoll       ()     ",[43,516,517],{},"      wcstoll       ()     ",[215,519,520,499,523],{},[43,521,522],{},"      LLONG_MIN     ",[43,524,525],{},"      LLONG_MAX     ",[215,527,528],{},[43,529,507],{},[200,531,532,540,545],{},[215,533,534,271,537],{},[43,535,536],{},"      strtoul       ()     ",[43,538,539],{},"      wcstoul       ()     ",[215,541,542],{},[43,543,544],{},"      ULONG_MAX     ",[215,546,547],{},[43,548,507],{},[200,550,551,559,564],{},[215,552,553,271,556],{},[43,554,555],{},"      strtoull       ()     ",[43,557,558],{},"      wcstoull       ()     ",[215,560,561],{},[43,562,563],{},"      ULLONG_MAX     ",[215,565,566],{},[43,567,507],{},[200,569,570,578,583],{},[215,571,572,271,575],{},[43,573,574],{},"      strtoumax       ()     ",[43,576,577],{},"      wcstoumax()     ",[215,579,580],{},[43,581,582],{},"      UINTMAX_MAX     ",[215,584,585],{},[43,586,507],{},[200,588,589,597,605],{},[215,590,591,271,594],{},[43,592,593],{},"      strtod       ()     ",[43,595,596],{},"      wcstod       ()     ",[215,598,599,499,602],{},[43,600,601],{},"      0     ",[43,603,604],{},"      ±HUGE_VAL     ",[215,606,607],{},[43,608,507],{},[200,610,611,619,626],{},[215,612,613,271,616],{},[43,614,615],{},"      strtof       ()     ",[43,617,618],{},"      wcstof()     ",[215,620,621,499,623],{},[43,622,601],{},[43,624,625],{},"      ±HUGE_VALF     ",[215,627,628],{},[43,629,507],{},[200,631,632,640,648],{},[215,633,634,271,637],{},[43,635,636],{},"      strtold       ()     ",[43,638,639],{},"      wcstold       ()     ",[215,641,642,499,645],{},[43,643,644],{},"     0    ",[43,646,647],{},"     ±HUGE_VALL    ",[215,649,650],{},[43,651,507],{},[200,653,654,662,670],{},[215,655,656,271,659],{},[43,657,658],{},"      strtoimax       ()     ",[43,660,661],{},"      wcstoimax()     ",[215,663,664,271,667],{},[43,665,666],{},"      INTMAX_MIN     ",[43,668,669],{},"      INTMAX_MAX     ",[215,671,672],{},[43,673,507],{},[148,675,677,678],{"id":676},"library-functions-that-do-not-promise-to-set-errno","Library Functions that Do Not Promise to Set ",[43,679,45],{},[39,681,682,683,685,686,689,690,113],{},"The C Standard fails to document the behavior of ",[43,684,45],{}," for some functions. For example, the ",[43,687,688],{},"setlocale()"," function normally returns a null pointer in the event of an error, but no guarantees are made about setting ",[43,691,45],{},[39,693,694,695,697,698,700,701,703,704,706,707,709],{},"After calling one of these functions, a program should not rely solely on the value of ",[43,696,45],{}," to determine if an error occurred. The function might have altered ",[43,699,45],{}," , but this does not ensure that ",[43,702,45],{}," will properly indicate an error condition. If the program does check ",[43,705,45],{}," after calling one of these functions, it should set ",[43,708,45],{}," to 0 before the function call.",[148,711,713],{"id":712},"library-functions-with-differing-standards-documentation","Library Functions with Differing Standards Documentation",[39,715,716,717,719,720,723,724,726,727,729,730,732,733,735,736,738,739,743,744,746,747,749,750,752,753,755],{},"Some functions behave differently regarding ",[43,718,45],{}," in various standards. The ",[43,721,722],{},"fopen()"," function is one such example. When ",[43,725,722],{}," encounters an error, it returns a null pointer. The C Standard makes no mention of ",[43,728,45],{}," when describing ",[43,731,722],{}," . However, POSIX.1 declares that when ",[43,734,722],{}," encounters an error, it returns a null pointer and sets ",[43,737,45],{}," to a value indicating the error [ ",[66,740,742],{"href":741},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-IEEEStd1003.1-2013","IEEE Std 1003.1-2013"," ]. The implication is that a program conforming to C but not to POSIX (such as a Windows program) should not check ",[43,745,45],{}," after calling ",[43,748,722],{}," , but a POSIX program may check ",[43,751,45],{}," if ",[43,754,722],{}," returns a null pointer.",[148,757,759,760],{"id":758},"library-functions-and-errno","Library Functions and ",[43,761,45],{},[39,763,764,765,767],{},"The following uses of ",[43,766,45],{}," are documented in the C Standard:",[118,769,770,780,825,838,865,876,885,898,910],{},[121,771,772,773,776,777,779],{},"Functions defined in ",[43,774,775],{},"\u003Ccomplex.h>"," may set ",[43,778,45],{}," but are not required to.",[121,781,782,783,255,786,255,789,792,793,796,797,799,800,802,803,396,805,807,808,810,811,813,814,818,819,821,822,824],{},"For numeric conversion functions in the ",[43,784,785],{},"strtod",[43,787,788],{},"strtol",[43,790,791],{},"wcstod"," , and ",[43,794,795],{},"wcstol"," families, if the correct result is outside the range of representable values, an appropriate minimum or maximum value is returned and the value ",[43,798,383],{}," is stored in ",[43,801,45],{}," . For floating-point conversion functions in the ",[43,804,785],{},[43,806,791],{}," families, if an underflow occurs, whether ",[43,809,45],{}," acquires the value ",[43,812,383],{}," is ",[66,815,817],{"href":816},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-implementation-definedbehavior","implementation-defined"," . If the conversion fails, ",[43,820,415],{}," is returned and ",[43,823,45],{}," is not set.",[121,826,827,828,831,832,835,836,113],{},"The numeric conversion function ",[43,829,830],{},"atof()"," and those in the ",[43,833,834],{},"atoi"," family \"need not affect the value of\" ",[43,837,45],{},[121,839,840,841,844,845,848,849,810,851,854,855,810,857,859,860,810,862,864],{},"For mathematical functions in ",[43,842,843],{},"\u003Cmath.h>"," , if the integer expression ",[43,846,847],{},"   math_errhandling & MATH_ERRNO  "," is nonzero, on a domain error, ",[43,850,45],{},[43,852,853],{},"EDOM"," ; on an overflow with default rounding or if the mathematical result is an exact infinity from finite arguments, ",[43,856,45],{},[43,858,383],{}," ; and on an underflow, whether ",[43,861,45],{},[43,863,383],{}," is implementation-defined.",[121,866,867,868,870,871,873,874,113],{},"If a request made by calling ",[43,869,177],{}," cannot be honored, a value of ",[43,872,184],{}," is returned and a positive value is stored in ",[43,875,45],{},[121,877,878,879,881,882,884],{},"The byte I\u002FO functions, wide-character I\u002FO functions, and multibyte conversion functions store the value of the macro ",[43,880,336],{}," in ",[43,883,45],{}," if and only if an encoding error occurs.",[121,886,887,888,396,890,892,893,895,896,113],{},"On failure, ",[43,889,254],{},[43,891,258],{}," return nonzero and store an ",[66,894,817],{"href":816}," positive value in ",[43,897,45],{},[121,899,887,900,902,903,905,906,895,908,113],{},[43,901,239],{}," returns ",[43,904,244],{}," and stores an ",[66,907,817],{"href":816},[43,909,45],{},[121,911,392,912,915,916,918,919,113],{},[43,913,914],{},"perror()"," function maps the error number in ",[43,917,45],{}," to a message and writes it to ",[43,920,921],{},"stderr",[39,923,924,925,927,928,930,931,380,933,935,936,255,939,255,942,255,945,255,948,792,951,954,955,957],{},"The POSIX.1 standard defines the use of ",[43,926,45],{}," by many more functions (including the C standard library function). POSIX also has a small set of functions that are exceptions to the rule. These functions have no return value reserved to indicate an error, but they still set ",[43,929,45],{}," on error. To detect an error, an application must set ",[43,932,45],{},[43,934,415],{}," before calling the function and check whether it is nonzero after the call. Affected functions include ",[43,937,938],{},"strcoll()",[43,940,941],{},"strxfrm()",[43,943,944],{},"strerror()",[43,946,947],{},"wcscoll()",[43,949,950],{},"wcsxfrm()",[43,952,953],{},"fwide()"," . The C Standard allows these functions to set ",[43,956,45],{}," to a nonzero value on success. Consequently, this type of error checking should be performed only on POSIX systems.",[148,959,961,962,964],{"id":960},"noncompliant-code-example-strtoul","Noncompliant Code Example ( ",[43,963,372],{}," )",[39,966,967,968,380,970,972,973,975,976,978,979,981,982,984,985,987],{},"This noncompliant code example fails to set ",[43,969,45],{},[43,971,415],{}," before invoking ",[43,974,372],{}," . If an error occurs, ",[43,977,372],{}," returns a valid value ( ",[43,980,376],{}," ), so ",[43,983,45],{}," is the only means of determining if ",[43,986,372],{}," ran successfully.",[989,990,992],"code-block",{"quality":991},"bad",[993,994,999],"pre",{"className":995,"code":996,"language":997,"meta":998,"style":998},"language-c shiki shiki-themes github-light github-dark monokai","#include \u003Cerrno.h>\n#include \u003Climits.h>\n#include \u003Cstdlib.h>\n \nvoid func(const char *c_str) {\n  unsigned long number;\n  char *endptr;\n  \n  number = strtoul(c_str, &endptr, 0);\n  if (endptr == c_str || (number == ULONG_MAX \n                         && errno == ERANGE)) {\n    \u002F* Handle error *\u002F\n  } else {\n    \u002F* Computation succeeded *\u002F\n  }\n}\n","c","",[43,1000,1001,1014,1022,1030,1037,1067,1079,1090,1096,1123,1149,1163,1170,1182,1188,1194],{"__ignoreMap":998},[1002,1003,1006,1010],"span",{"class":1004,"line":1005},"line",1,[1002,1007,1009],{"class":1008},"sC2Qs","#include",[1002,1011,1013],{"class":1012},"sstjo"," \u003Cerrno.h>\n",[1002,1015,1017,1019],{"class":1004,"line":1016},2,[1002,1018,1009],{"class":1008},[1002,1020,1021],{"class":1012}," \u003Climits.h>\n",[1002,1023,1025,1027],{"class":1004,"line":1024},3,[1002,1026,1009],{"class":1008},[1002,1028,1029],{"class":1012}," \u003Cstdlib.h>\n",[1002,1031,1033],{"class":1004,"line":1032},4,[1002,1034,1036],{"class":1035},"sMOD_"," \n",[1002,1038,1040,1044,1048,1051,1054,1057,1060,1064],{"class":1004,"line":1039},5,[1002,1041,1043],{"class":1042},"sq6CD","void",[1002,1045,1047],{"class":1046},"srTi1"," func",[1002,1049,1050],{"class":1035},"(",[1002,1052,1053],{"class":1008},"const",[1002,1055,1056],{"class":1042}," char",[1002,1058,1059],{"class":1008}," *",[1002,1061,1063],{"class":1062},"sTHNf","c_str",[1002,1065,1066],{"class":1035},") {\n",[1002,1068,1070,1073,1076],{"class":1004,"line":1069},6,[1002,1071,1072],{"class":1042},"  unsigned",[1002,1074,1075],{"class":1042}," long",[1002,1077,1078],{"class":1035}," number;\n",[1002,1080,1082,1085,1087],{"class":1004,"line":1081},7,[1002,1083,1084],{"class":1042},"  char",[1002,1086,1059],{"class":1008},[1002,1088,1089],{"class":1035},"endptr;\n",[1002,1091,1093],{"class":1004,"line":1092},8,[1002,1094,1095],{"class":1035},"  \n",[1002,1097,1099,1102,1105,1108,1111,1114,1117,1120],{"class":1004,"line":1098},9,[1002,1100,1101],{"class":1035},"  number ",[1002,1103,1104],{"class":1008},"=",[1002,1106,1107],{"class":1046}," strtoul",[1002,1109,1110],{"class":1035},"(c_str, ",[1002,1112,1113],{"class":1008},"&",[1002,1115,1116],{"class":1035},"endptr, ",[1002,1118,415],{"class":1119},"s7F3e",[1002,1121,1122],{"class":1035},");\n",[1002,1124,1126,1129,1132,1135,1138,1141,1144,1146],{"class":1004,"line":1125},10,[1002,1127,1128],{"class":1008},"  if",[1002,1130,1131],{"class":1035}," (endptr ",[1002,1133,1134],{"class":1008},"==",[1002,1136,1137],{"class":1035}," c_str ",[1002,1139,1140],{"class":1008},"||",[1002,1142,1143],{"class":1035}," (number ",[1002,1145,1134],{"class":1008},[1002,1147,1148],{"class":1035}," ULONG_MAX \n",[1002,1150,1152,1155,1158,1160],{"class":1004,"line":1151},11,[1002,1153,1154],{"class":1008},"                         &&",[1002,1156,1157],{"class":1035}," errno ",[1002,1159,1134],{"class":1008},[1002,1161,1162],{"class":1035}," ERANGE)) {\n",[1002,1164,1166],{"class":1004,"line":1165},12,[1002,1167,1169],{"class":1168},"s8-w5","    \u002F* Handle error *\u002F\n",[1002,1171,1173,1176,1179],{"class":1004,"line":1172},13,[1002,1174,1175],{"class":1035},"  } ",[1002,1177,1178],{"class":1008},"else",[1002,1180,1181],{"class":1035}," {\n",[1002,1183,1185],{"class":1004,"line":1184},14,[1002,1186,1187],{"class":1168},"    \u002F* Computation succeeded *\u002F\n",[1002,1189,1191],{"class":1004,"line":1190},15,[1002,1192,1193],{"class":1035},"  }\n",[1002,1195,1197],{"class":1004,"line":1196},16,[1002,1198,1199],{"class":1035},"}\n",[39,1201,1202],{},"Any error detected in this manner may have occurred earlier in the program or may not represent an actual error.",[148,1204,1206,1207,964],{"id":1205},"compliant-solution-strtoul","Compliant Solution ( ",[43,1208,372],{},[39,1210,1211,1212,380,1214,1216,1217,1219,1220,1222],{},"This compliant solution sets ",[43,1213,45],{},[43,1215,415],{}," before the call to ",[43,1218,372],{}," and inspects ",[43,1221,45],{}," after the call:",[989,1224,1226],{"quality":1225},"good",[993,1227,1229],{"className":995,"code":1228,"language":997,"meta":998,"style":998},"#include \u003Cerrno.h>\n#include \u003Climits.h>\n#include \u003Cstdlib.h>\n \nvoid func(const char *c_str) {\n  unsigned long number;\n  char *endptr;\n \n  errno = 0;\n  number = strtoul(c_str, &endptr, 0);\n  if (endptr == c_str || (number == ULONG_MAX \n                         && errno == ERANGE)) {\n    \u002F* Handle error *\u002F\n  } else {\n    \u002F* Computation succeeded *\u002F\n  }\n}\n",[43,1230,1231,1237,1243,1249,1253,1271,1279,1287,1291,1304,1322,1340,1350,1354,1362,1366,1370],{"__ignoreMap":998},[1002,1232,1233,1235],{"class":1004,"line":1005},[1002,1234,1009],{"class":1008},[1002,1236,1013],{"class":1012},[1002,1238,1239,1241],{"class":1004,"line":1016},[1002,1240,1009],{"class":1008},[1002,1242,1021],{"class":1012},[1002,1244,1245,1247],{"class":1004,"line":1024},[1002,1246,1009],{"class":1008},[1002,1248,1029],{"class":1012},[1002,1250,1251],{"class":1004,"line":1032},[1002,1252,1036],{"class":1035},[1002,1254,1255,1257,1259,1261,1263,1265,1267,1269],{"class":1004,"line":1039},[1002,1256,1043],{"class":1042},[1002,1258,1047],{"class":1046},[1002,1260,1050],{"class":1035},[1002,1262,1053],{"class":1008},[1002,1264,1056],{"class":1042},[1002,1266,1059],{"class":1008},[1002,1268,1063],{"class":1062},[1002,1270,1066],{"class":1035},[1002,1272,1273,1275,1277],{"class":1004,"line":1069},[1002,1274,1072],{"class":1042},[1002,1276,1075],{"class":1042},[1002,1278,1078],{"class":1035},[1002,1280,1281,1283,1285],{"class":1004,"line":1081},[1002,1282,1084],{"class":1042},[1002,1284,1059],{"class":1008},[1002,1286,1089],{"class":1035},[1002,1288,1289],{"class":1004,"line":1092},[1002,1290,1036],{"class":1035},[1002,1292,1293,1296,1298,1301],{"class":1004,"line":1098},[1002,1294,1295],{"class":1035},"  errno ",[1002,1297,1104],{"class":1008},[1002,1299,1300],{"class":1119}," 0",[1002,1302,1303],{"class":1035},";\n",[1002,1305,1306,1308,1310,1312,1314,1316,1318,1320],{"class":1004,"line":1125},[1002,1307,1101],{"class":1035},[1002,1309,1104],{"class":1008},[1002,1311,1107],{"class":1046},[1002,1313,1110],{"class":1035},[1002,1315,1113],{"class":1008},[1002,1317,1116],{"class":1035},[1002,1319,415],{"class":1119},[1002,1321,1122],{"class":1035},[1002,1323,1324,1326,1328,1330,1332,1334,1336,1338],{"class":1004,"line":1151},[1002,1325,1128],{"class":1008},[1002,1327,1131],{"class":1035},[1002,1329,1134],{"class":1008},[1002,1331,1137],{"class":1035},[1002,1333,1140],{"class":1008},[1002,1335,1143],{"class":1035},[1002,1337,1134],{"class":1008},[1002,1339,1148],{"class":1035},[1002,1341,1342,1344,1346,1348],{"class":1004,"line":1165},[1002,1343,1154],{"class":1008},[1002,1345,1157],{"class":1035},[1002,1347,1134],{"class":1008},[1002,1349,1162],{"class":1035},[1002,1351,1352],{"class":1004,"line":1172},[1002,1353,1169],{"class":1168},[1002,1355,1356,1358,1360],{"class":1004,"line":1184},[1002,1357,1175],{"class":1035},[1002,1359,1178],{"class":1008},[1002,1361,1181],{"class":1035},[1002,1363,1364],{"class":1004,"line":1190},[1002,1365,1187],{"class":1168},[1002,1367,1368],{"class":1004,"line":1196},[1002,1369,1193],{"class":1035},[1002,1371,1373],{"class":1004,"line":1372},17,[1002,1374,1199],{"class":1035},[148,1376,961,1378,964],{"id":1377},"noncompliant-code-example-ftell",[43,1379,239],{},[39,1381,1382,1383,1385,1386,1388,1389,1391],{},"This noncompliant code example, after calling ",[43,1384,239],{}," , examines ",[43,1387,45],{}," without first checking whether the out-of-band indicator returned by ",[43,1390,239],{}," indicates an error.",[989,1393,1394],{"quality":991},[993,1395,1397],{"className":995,"code":1396,"language":997,"meta":998,"style":998},"#include \u003Cerrno.h>\n#include \u003Cstdio.h>\n\nvoid func(FILE* fp) { \n  errno=0;\n  ftell(fp);\n  if (errno) {\n    perror(\"ftell\");\n  }\n}\n",[43,1398,1399,1405,1412,1417,1435,1446,1454,1461,1473,1477],{"__ignoreMap":998},[1002,1400,1401,1403],{"class":1004,"line":1005},[1002,1402,1009],{"class":1008},[1002,1404,1013],{"class":1012},[1002,1406,1407,1409],{"class":1004,"line":1016},[1002,1408,1009],{"class":1008},[1002,1410,1411],{"class":1012}," \u003Cstdio.h>\n",[1002,1413,1414],{"class":1004,"line":1024},[1002,1415,1416],{"emptyLinePlaceholder":7},"\n",[1002,1418,1419,1421,1423,1426,1429,1432],{"class":1004,"line":1032},[1002,1420,1043],{"class":1042},[1002,1422,1047],{"class":1046},[1002,1424,1425],{"class":1035},"(FILE",[1002,1427,1428],{"class":1008},"*",[1002,1430,1431],{"class":1062}," fp",[1002,1433,1434],{"class":1035},") { \n",[1002,1436,1437,1440,1442,1444],{"class":1004,"line":1039},[1002,1438,1439],{"class":1035},"  errno",[1002,1441,1104],{"class":1008},[1002,1443,415],{"class":1119},[1002,1445,1303],{"class":1035},[1002,1447,1448,1451],{"class":1004,"line":1069},[1002,1449,1450],{"class":1046},"  ftell",[1002,1452,1453],{"class":1035},"(fp);\n",[1002,1455,1456,1458],{"class":1004,"line":1081},[1002,1457,1128],{"class":1008},[1002,1459,1460],{"class":1035}," (errno) {\n",[1002,1462,1463,1466,1468,1471],{"class":1004,"line":1092},[1002,1464,1465],{"class":1046},"    perror",[1002,1467,1050],{"class":1035},[1002,1469,1470],{"class":1012},"\"ftell\"",[1002,1472,1122],{"class":1035},[1002,1474,1475],{"class":1004,"line":1098},[1002,1476,1193],{"class":1035},[1002,1478,1479],{"class":1004,"line":1125},[1002,1480,1199],{"class":1035},[148,1482,1206,1484,964],{"id":1483},"compliant-solution-ftell",[43,1485,239],{},[39,1487,1488,1489,1491,1492,1494,1495,1497],{},"This compliant solution first detects that ",[43,1490,239],{}," failed using its out-of-band error indicator. Once an error has been confirmed, reading ",[43,1493,45],{}," (implicitly by using the ",[43,1496,914],{}," function) is permitted.",[989,1499,1500],{"quality":1225},[993,1501,1503],{"className":995,"code":1502,"language":997,"meta":998,"style":998},"#include \u003Cerrno.h>\n#include \u003Cstdio.h>\n\nvoid func(FILE* fp) { \n  if (ftell(fp) == -1) {\n    perror(\"ftell\");\n  }\n}\n",[43,1504,1505,1511,1517,1521,1535,1558,1568,1572],{"__ignoreMap":998},[1002,1506,1507,1509],{"class":1004,"line":1005},[1002,1508,1009],{"class":1008},[1002,1510,1013],{"class":1012},[1002,1512,1513,1515],{"class":1004,"line":1016},[1002,1514,1009],{"class":1008},[1002,1516,1411],{"class":1012},[1002,1518,1519],{"class":1004,"line":1024},[1002,1520,1416],{"emptyLinePlaceholder":7},[1002,1522,1523,1525,1527,1529,1531,1533],{"class":1004,"line":1032},[1002,1524,1043],{"class":1042},[1002,1526,1047],{"class":1046},[1002,1528,1425],{"class":1035},[1002,1530,1428],{"class":1008},[1002,1532,1431],{"class":1062},[1002,1534,1434],{"class":1035},[1002,1536,1537,1539,1542,1545,1548,1550,1553,1556],{"class":1004,"line":1039},[1002,1538,1128],{"class":1008},[1002,1540,1541],{"class":1035}," (",[1002,1543,1544],{"class":1046},"ftell",[1002,1546,1547],{"class":1035},"(fp) ",[1002,1549,1134],{"class":1008},[1002,1551,1552],{"class":1008}," -",[1002,1554,1555],{"class":1119},"1",[1002,1557,1066],{"class":1035},[1002,1559,1560,1562,1564,1566],{"class":1004,"line":1069},[1002,1561,1465],{"class":1046},[1002,1563,1050],{"class":1035},[1002,1565,1470],{"class":1012},[1002,1567,1122],{"class":1035},[1002,1569,1570],{"class":1004,"line":1081},[1002,1571,1193],{"class":1035},[1002,1573,1574],{"class":1004,"line":1092},[1002,1575,1199],{"class":1035},[148,1577,961,1579,964],{"id":1578},"noncompliant-code-example-fopen",[43,1580,722],{},[39,1582,1583,1584,1586,1587,1589],{},"This noncompliant code example may fail to diagnose errors because ",[43,1585,722],{}," might not set ",[43,1588,45],{}," even if an error occurs:",[989,1591,1592],{"quality":991},[993,1593,1595],{"className":995,"code":1594,"language":997,"meta":998,"style":998},"#include \u003Cerrno.h>\n#include \u003Cstdio.h>\n \nvoid func(const char *filename) {\n  FILE *fileptr;\n\n  errno = 0;\n  fileptr = fopen(filename, \"rb\");\n  if (errno != 0) {\n    \u002F* Handle error *\u002F\n  }\n}\n",[43,1596,1597,1603,1609,1613,1632,1642,1646,1656,1674,1688,1692,1696],{"__ignoreMap":998},[1002,1598,1599,1601],{"class":1004,"line":1005},[1002,1600,1009],{"class":1008},[1002,1602,1013],{"class":1012},[1002,1604,1605,1607],{"class":1004,"line":1016},[1002,1606,1009],{"class":1008},[1002,1608,1411],{"class":1012},[1002,1610,1611],{"class":1004,"line":1024},[1002,1612,1036],{"class":1035},[1002,1614,1615,1617,1619,1621,1623,1625,1627,1630],{"class":1004,"line":1032},[1002,1616,1043],{"class":1042},[1002,1618,1047],{"class":1046},[1002,1620,1050],{"class":1035},[1002,1622,1053],{"class":1008},[1002,1624,1056],{"class":1042},[1002,1626,1059],{"class":1008},[1002,1628,1629],{"class":1062},"filename",[1002,1631,1066],{"class":1035},[1002,1633,1634,1637,1639],{"class":1004,"line":1039},[1002,1635,1636],{"class":1035},"  FILE ",[1002,1638,1428],{"class":1008},[1002,1640,1641],{"class":1035},"fileptr;\n",[1002,1643,1644],{"class":1004,"line":1069},[1002,1645,1416],{"emptyLinePlaceholder":7},[1002,1647,1648,1650,1652,1654],{"class":1004,"line":1081},[1002,1649,1295],{"class":1035},[1002,1651,1104],{"class":1008},[1002,1653,1300],{"class":1119},[1002,1655,1303],{"class":1035},[1002,1657,1658,1661,1663,1666,1669,1672],{"class":1004,"line":1092},[1002,1659,1660],{"class":1035},"  fileptr ",[1002,1662,1104],{"class":1008},[1002,1664,1665],{"class":1046}," fopen",[1002,1667,1668],{"class":1035},"(filename, ",[1002,1670,1671],{"class":1012},"\"rb\"",[1002,1673,1122],{"class":1035},[1002,1675,1676,1678,1681,1684,1686],{"class":1004,"line":1098},[1002,1677,1128],{"class":1008},[1002,1679,1680],{"class":1035}," (errno ",[1002,1682,1683],{"class":1008},"!=",[1002,1685,1300],{"class":1119},[1002,1687,1066],{"class":1035},[1002,1689,1690],{"class":1004,"line":1125},[1002,1691,1169],{"class":1168},[1002,1693,1694],{"class":1004,"line":1151},[1002,1695,1193],{"class":1035},[1002,1697,1698],{"class":1004,"line":1165},[1002,1699,1199],{"class":1035},[148,1701,1206,1703,1705],{"id":1702},"compliant-solution-fopen-c",[43,1704,722],{}," , C)",[39,1707,1708,1709,729,1711,1713,1714,1716,1717,1719],{},"The C Standard makes no mention of ",[43,1710,45],{},[43,1712,722],{}," . In this compliant solution, the results of the call to ",[43,1715,722],{}," are used to determine failure and ",[43,1718,45],{}," is not checked:",[989,1721,1722],{"quality":1225},[993,1723,1725],{"className":995,"code":1724,"language":997,"meta":998,"style":998},"#include \u003Cstdio.h>\n \nvoid func(const char *filename) {\n  FILE *fileptr = fopen(filename, \"rb\");\n  if (fileptr == NULL)  {\n    \u002F* An error occurred in fopen() *\u002F\n  }\n}\n",[43,1726,1727,1733,1737,1755,1774,1789,1794,1798],{"__ignoreMap":998},[1002,1728,1729,1731],{"class":1004,"line":1005},[1002,1730,1009],{"class":1008},[1002,1732,1411],{"class":1012},[1002,1734,1735],{"class":1004,"line":1016},[1002,1736,1036],{"class":1035},[1002,1738,1739,1741,1743,1745,1747,1749,1751,1753],{"class":1004,"line":1024},[1002,1740,1043],{"class":1042},[1002,1742,1047],{"class":1046},[1002,1744,1050],{"class":1035},[1002,1746,1053],{"class":1008},[1002,1748,1056],{"class":1042},[1002,1750,1059],{"class":1008},[1002,1752,1629],{"class":1062},[1002,1754,1066],{"class":1035},[1002,1756,1757,1759,1761,1764,1766,1768,1770,1772],{"class":1004,"line":1032},[1002,1758,1636],{"class":1035},[1002,1760,1428],{"class":1008},[1002,1762,1763],{"class":1035},"fileptr ",[1002,1765,1104],{"class":1008},[1002,1767,1665],{"class":1046},[1002,1769,1668],{"class":1035},[1002,1771,1671],{"class":1012},[1002,1773,1122],{"class":1035},[1002,1775,1776,1778,1781,1783,1786],{"class":1004,"line":1039},[1002,1777,1128],{"class":1008},[1002,1779,1780],{"class":1035}," (fileptr ",[1002,1782,1134],{"class":1008},[1002,1784,1785],{"class":1119}," NULL",[1002,1787,1788],{"class":1035},")  {\n",[1002,1790,1791],{"class":1004,"line":1069},[1002,1792,1793],{"class":1168},"    \u002F* An error occurred in fopen() *\u002F\n",[1002,1795,1796],{"class":1004,"line":1081},[1002,1797,1193],{"class":1035},[1002,1799,1800],{"class":1004,"line":1092},[1002,1801,1199],{"class":1035},[148,1803,1206,1805,1807],{"id":1804},"compliant-solution-fopen-posix",[43,1806,722],{}," , POSIX)",[39,1809,1810,1811,1813],{},"In this compliant solution, ",[43,1812,45],{}," is checked only after an error has already been detected by another means:",[989,1815,1816],{"quality":1225},[993,1817,1819],{"className":995,"code":1818,"language":997,"meta":998,"style":998},"#include \u003Cerrno.h>\n#include \u003Cstdio.h>\n \nvoid func(const char *filename) {\n  FILE *fileptr;\n\n  errno = 0;\n  fileptr = fopen(filename, \"rb\");\n  if (fileptr == NULL)  {\n    \u002F*\n     * An error occurred in fopen(); now it's valid \n     * to examine errno.\n     *\u002F\n    perror(filename);\n  }\n}\n",[43,1820,1821,1827,1833,1837,1855,1863,1867,1877,1891,1903,1908,1913,1918,1923,1930,1934],{"__ignoreMap":998},[1002,1822,1823,1825],{"class":1004,"line":1005},[1002,1824,1009],{"class":1008},[1002,1826,1013],{"class":1012},[1002,1828,1829,1831],{"class":1004,"line":1016},[1002,1830,1009],{"class":1008},[1002,1832,1411],{"class":1012},[1002,1834,1835],{"class":1004,"line":1024},[1002,1836,1036],{"class":1035},[1002,1838,1839,1841,1843,1845,1847,1849,1851,1853],{"class":1004,"line":1032},[1002,1840,1043],{"class":1042},[1002,1842,1047],{"class":1046},[1002,1844,1050],{"class":1035},[1002,1846,1053],{"class":1008},[1002,1848,1056],{"class":1042},[1002,1850,1059],{"class":1008},[1002,1852,1629],{"class":1062},[1002,1854,1066],{"class":1035},[1002,1856,1857,1859,1861],{"class":1004,"line":1039},[1002,1858,1636],{"class":1035},[1002,1860,1428],{"class":1008},[1002,1862,1641],{"class":1035},[1002,1864,1865],{"class":1004,"line":1069},[1002,1866,1416],{"emptyLinePlaceholder":7},[1002,1868,1869,1871,1873,1875],{"class":1004,"line":1081},[1002,1870,1295],{"class":1035},[1002,1872,1104],{"class":1008},[1002,1874,1300],{"class":1119},[1002,1876,1303],{"class":1035},[1002,1878,1879,1881,1883,1885,1887,1889],{"class":1004,"line":1092},[1002,1880,1660],{"class":1035},[1002,1882,1104],{"class":1008},[1002,1884,1665],{"class":1046},[1002,1886,1668],{"class":1035},[1002,1888,1671],{"class":1012},[1002,1890,1122],{"class":1035},[1002,1892,1893,1895,1897,1899,1901],{"class":1004,"line":1098},[1002,1894,1128],{"class":1008},[1002,1896,1780],{"class":1035},[1002,1898,1134],{"class":1008},[1002,1900,1785],{"class":1119},[1002,1902,1788],{"class":1035},[1002,1904,1905],{"class":1004,"line":1125},[1002,1906,1907],{"class":1168},"    \u002F*\n",[1002,1909,1910],{"class":1004,"line":1151},[1002,1911,1912],{"class":1168},"     * An error occurred in fopen(); now it's valid \n",[1002,1914,1915],{"class":1004,"line":1165},[1002,1916,1917],{"class":1168},"     * to examine errno.\n",[1002,1919,1920],{"class":1004,"line":1172},[1002,1921,1922],{"class":1168},"     *\u002F\n",[1002,1924,1925,1927],{"class":1004,"line":1184},[1002,1926,1465],{"class":1046},[1002,1928,1929],{"class":1035},"(filename);\n",[1002,1931,1932],{"class":1004,"line":1190},[1002,1933,1193],{"class":1035},[1002,1935,1936],{"class":1004,"line":1196},[1002,1937,1199],{"class":1035},[148,1939,1941],{"id":1940},"risk-assessment","Risk Assessment",[39,1943,1944,1945,1947],{},"The improper use of ",[43,1946,45],{}," may result in failing to detect an error condition or in incorrectly identifying an error condition when none exists.",[194,1949,1950,1951,1950,1978],{},"\n  ",[197,1952,1953,1954,1950],{},"\n    ",[200,1955,1956,1957,1956,1960,1956,1963,1956,1966,1956,1969,1956,1972,1956,1975,1953],{},"\n      ",[203,1958,1959],{},"Rule",[203,1961,1962],{},"Severity",[203,1964,1965],{},"Likelihood",[203,1967,1968],{},"Detectable",[203,1970,1971],{},"Repairable",[203,1973,1974],{},"Priority",[203,1976,1977],{},"Level",[210,1979,1953,1980,1950],{},[200,1981,1956,1982,1956,1985,1956,1988,1956,1991,1956,1994,1956,1996,1956,2003,1953],{},[215,1983,1984],{},"ERR30-C",[215,1986,1987],{},"Medium",[215,1989,1990],{},"Probable",[215,1992,1993],{},"Yes",[215,1995,1993],{},[215,1997,1999],{"style":1998},"color: #e74c3c;",[2000,2001,2002],"b",{},"P12",[215,2004,2005],{"style":1998},[2000,2006,2007],{},"L1",[2009,2010,2012],"h3",{"id":2011},"automated-detection","Automated Detection",[194,2014,2017],{"className":2015},[2016],"wrapped",[210,2018,2019,2043,2082,2108,2135,2160,2201,2227,2260,2295,2321,2347,2394],{},[200,2020,2023,2028,2033,2038],{"className":2021},[2022],"header",[203,2024,2025],{},[39,2026,2027],{},"Tool",[203,2029,2030],{},[39,2031,2032],{},"Version",[203,2034,2035],{},[39,2036,2037],{},"Checker",[203,2039,2040],{},[39,2041,2042],{},"Description",[200,2044,2047,2053,2061,2079],{"className":2045},[2046],"odd",[215,2048,2049],{},[66,2050,2052],{"href":2051},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fastree","Astrée",[215,2054,2055],{},[2056,2057,2060],"div",{"className":2058},[2059],"content-wrapper","25.10",[215,2062,2063],{},[39,2064,2065,2068,2071,2074,2076],{},[188,2066,2067],{},"chained-errno-function-calls",[2069,2070],"br",{},[188,2072,2073],{},"errno-reset",[2069,2075],{},[188,2077,2078],{},"errno-test-after-wrong-call",[215,2080,2081],{},"Partially checked",[200,2083,2086,2092,2100,2105],{"className":2084},[2085],"even",[215,2087,2088],{},[66,2089,2091],{"href":2090},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Faxivion-bauhaus-suite","Axivion Bauhaus Suite",[215,2093,2094],{},[2056,2095,2097],{"className":2096},[2059],[39,2098,2099],{},"7.2.0",[215,2101,2102],{},[188,2103,2104],{},"CertC-ERR30",[215,2106,2107],{},"Fully implemented",[200,2109,2111,2117,2123,2130],{"className":2110},[2046],[215,2112,2113],{},[66,2114,2116],{"href":2115},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcodesonar","CodeSonar",[215,2118,2119],{},[2056,2120,2122],{"className":2121},[2059],"9.1p0",[215,2124,2125],{},[39,2126,2127],{},[188,2128,2129],{},"LANG.STRUCT.RC",[215,2131,2132],{},[39,2133,2134],{},"Redundant Condition",[200,2136,2138,2144,2148,2152],{"className":2137},[2085],[215,2139,2140],{},[66,2141,2143],{"href":2142},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Frose","Compass\u002FROSE",[215,2145,2146],{},[2069,2147],{},[215,2149,2150],{},[2069,2151],{},[215,2153,2154],{},[39,2155,2156,2157],{},"Could detect violations of this rule by ensuring that each library function is accompanied by the proper treatment of ",[43,2158,2159],{},"       errno      ",[200,2161,2163,2169,2175,2198],{"className":2162},[2046],[215,2164,2165],{},[66,2166,2168],{"href":2167},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcoverity","Coverity",[215,2170,2171],{},[2056,2172,2174],{"className":2173},[2059],"2017.07",[215,2176,2177,2182,2189],{},[39,2178,2179],{},[188,2180,2181],{},"MISRA C 2012 Rule 22.8",[39,2183,2184],{},[188,2185,2186],{},[188,2187,2188],{},"MISRA C 2012 Rule 22.9",[39,2190,2191],{},[188,2192,2193],{},[188,2194,2195],{},[188,2196,2197],{},"MISRA C 2012 Rule 22.10",[215,2199,2200],{},"Implemented",[200,2202,2204,2210,2218,2223],{"className":2203},[2085],[215,2205,2206],{},[66,2207,2209],{"href":2208},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcppcheck-premium","Cppcheck Premium",[215,2211,2212],{},[2056,2213,2215],{"className":2214},[2059],[39,2216,2217],{},"24.11.0",[215,2219,2220],{},[188,2221,2222],{},"premium-cert-err30-c",[215,2224,2225],{},[2069,2226],{},[200,2228,2230,2236,2244,2256],{"className":2229},[2046],[215,2231,2232],{},[66,2233,2235],{"href":2234},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fhelix-qac","Helix QAC",[215,2237,2238],{},[2056,2239,2241],{"className":2240},[2059],[39,2242,2243],{},"2025.2",[215,2245,2246,2251],{},[39,2247,2248],{},[188,2249,2250],{},"C2500, C2501, C2502, C2503",[39,2252,2253],{},[188,2254,2255],{},"C++3172, C++3173, C++3174, C++3175, C++3176, C++3177, C++3178, C++3179, C++3183, C++3184",[215,2257,2258],{},[2069,2259],{},[200,2261,2263,2269,2274,2291],{"className":2262},[2085],[215,2264,2265],{},[66,2266,2268],{"href":2267},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fklocwork","Klocwork",[215,2270,2271],{},[2056,2272,2243],{"className":2273},[2059],[215,2275,2276],{},[39,2277,2278,2281,2283,2286,2288],{},[188,2279,2280],{},"CXX.ERRNO.NOT_SET",[2069,2282],{},[188,2284,2285],{},"CXX.ERRNO.NOT_CHECKED",[2069,2287],{},[188,2289,2290],{},"CXX.ERRNO.INCORRECTLY_CHECKED",[215,2292,2293],{},[2069,2294],{},[200,2296,2298,2304,2310,2319],{"className":2297},[2046],[215,2299,2300],{},[66,2301,2303],{"href":2302},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fldra","LDRA tool suite",[215,2305,2306],{},[2056,2307,2309],{"className":2308},[2059],"9.7.1",[215,2311,2312],{},[39,2313,2314],{},[188,2315,2316,2317],{},"111 D, 121 D, 122 D, 132  D, 134 D",[2069,2318],{},[215,2320,2107],{},[200,2322,2324,2330,2335,2342],{"className":2323},[2085],[215,2325,2326],{},[66,2327,2329],{"href":2328},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fparasoft","Parasoft C\u002FC++test",[215,2331,2332],{},[2056,2333,2243],{"className":2334},[2059],[215,2336,2337],{},[39,2338,2339],{},[188,2340,2341],{},"CERT_C-ERR30-a",[215,2343,2344],{},[39,2345,2346],{},"Properly use errno value",[200,2348,2350,2358,2366,2378],{"className":2349},[2046],[215,2351,2352],{},[39,2353,2354],{},[66,2355,2357],{"href":2356},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpolyspace-bug-finder","Polyspace Bug Finder",[215,2359,2360],{},[2056,2361,2363],{"className":2362},[2059],[39,2364,2365],{},"R2025b",[215,2367,2368,2374],{},[39,2369,2370],{},[66,2371,2373],{"href":2372},"https:\u002F\u002Fwww.mathworks.com\u002Fhelp\u002Fbugfinder\u002Fref\u002Fcertcruleerr30c.html","CERT C: Rule ERR30-C",[39,2375,2376],{},[2069,2377],{},[215,2379,2380,2383,2391],{},[39,2381,2382],{},"Checks for:",[118,2384,2385,2388],{},[121,2386,2387],{},"Misuse of errno",[121,2389,2390],{},"Errno not reset",[39,2392,2393],{},"Rule fully covered.",[200,2395,2397,2403,2410,2418],{"className":2396},[2085],[215,2398,2399],{},[66,2400,2402],{"href":2401},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Frulechecker","RuleChecker",[215,2404,2405],{},[2056,2406,2408],{"className":2407},[2059],[39,2409,2060],{},[215,2411,2412,2414,2416],{},[188,2413,2067],{},[2069,2415],{},[188,2417,2078],{},[215,2419,2081],{},[2009,2421,2423],{"id":2422},"related-vulnerabilities","Related Vulnerabilities",[39,2425,2426,2427,2431,2432,113],{},"Search for ",[66,2428,2430],{"href":2429},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-vulnerability","vulnerabilities"," resulting from the violation of this rule on the ",[66,2433,2437],{"href":2434,"rel":2435},"https:\u002F\u002Fwww.kb.cert.org\u002Fvulnotes\u002Fbymetric?searchview&query=FIELD+KEYWORDS+contains+ERR30-C",[2436],"nofollow","CERT website",[148,2439,2441],{"id":2440},"related-guidelines","Related Guidelines",[39,2443,2444,2448],{},[66,2445,2447],{"href":2446},"\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fhow-this-coding-standard-is-organized#HowthisCodingStandardisOrganized-RelatedGuidelines","Key here"," (explains table format and definitions)",[194,2450,2451,2461],{},[197,2452,2453],{},[200,2454,2455,2457,2459],{},[203,2456],{},[203,2458],{},[203,2460],{},[210,2462,2463,2474,2491,2507],{},[200,2464,2465,2468,2471],{},[215,2466,2467],{},"Taxonomy",[215,2469,2470],{},"Taxonomy item",[215,2472,2473],{},"Relationship",[200,2475,2476,2482,2488],{},[215,2477,2478],{},[66,2479,2481],{"href":2480},"#","CERT C Secure Coding Standard",[215,2483,2484],{},[66,2485,2487],{"href":2486},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp12-c","EXP12-C. Do not ignore values returned by functions",[215,2489,2490],{},"Prior to 2018-01-12: CERT: Unspecified Relationship",[200,2492,2493,2499,2505],{},[215,2494,2495],{},[66,2496,2498],{"href":2497},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-ISO-IECTS17961","ISO\u002FIEC TS 17961:2013",[215,2500,2501,2502,2504],{},"Incorrectly setting and using ",[43,2503,45],{}," [inverrno]",[215,2506,2490],{},[200,2508,2509,2516,2524],{},[215,2510,2511],{},[66,2512,2515],{"href":2513,"rel":2514},"https:\u002F\u002Fcwe.mitre.org\u002Fdata\u002Findex.html",[2436],"CWE 2.11",[215,2517,2518,2523],{},[66,2519,2522],{"href":2520,"rel":2521},"http:\u002F\u002Fcwe.mitre.org\u002Fdata\u002Fdefinitions\u002F456.html",[2436],"CWE-456"," , Missing Initialization of a Variable",[215,2525,2526],{},"2017-07-05: CERT: Rule subset of CWE",[148,2528,2530],{"id":2529},"cert-cwe-mapping-notes","CERT-CWE Mapping Notes",[39,2532,2533,2536],{},[66,2534,2447],{"href":2535},"\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fhow-this-coding-standard-is-organized#HowthisCodingStandardisOrganized-CERT-CWEMappingNotes"," for mapping notes",[2009,2538,2540],{"id":2539},"cwe-456-and-err30-c","CWE-456 and ERR30-C",[39,2542,2543],{},"CWE-456 = EXP33-C",[39,2545,2546],{},"CWE-456 = Union( ERR30-C, list) where list =",[118,2548,2549],{},[121,2550,2551],{},"Reading potentially uninitialized variables besides errno",[2009,2553,2555],{"id":2554},"cwe-248-and-err30-c","CWE-248 and ERR30-C",[39,2557,2558],{},"Intersection( CWE-248, ERR30-C) = Ø",[39,2560,2561],{},"CWE-248 is only for languages that support exceptions.  It lists C++ and Java, but not C.",[148,2563,2565],{"id":2564},"bibliography","Bibliography",[194,2567,2569,2578],{"className":2568},[2016],[2570,2571,2572,2576],"colgroup",{},[2573,2574],"col",{"style":2575},"width: 50%",[2573,2577],{"style":2575},[210,2579,2580,2597,2612,2625,2637],{},[200,2581,2583,2591],{"className":2582},[2046],[215,2584,2585,2586,2590],{},"[ ",[66,2587,2589],{"href":2588},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-Brainbell.com","Brainbell.com"," ]",[215,2592,2593],{},[66,2594,2596],{"href":2595},"http:\u002F\u002Fwww.brainbell.com\u002Ftutors\u002Fc\u002FAdvice_and_Warnings_for_C\u002FMacros_and_Miscellaneous_Pitfalls.html","Macros and Miscellaneous Pitfalls",[200,2598,2600,2606],{"className":2599},[2085],[215,2601,2585,2602,2590],{},[66,2603,2605],{"href":2604},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-Horton90","Horton 1990",[215,2607,2608,2609,2611],{},"Section 11, p. 168",[2069,2610],{},"\nSection 14, p. 254",[200,2613,2615,2619],{"className":2614},[2046],[215,2616,2585,2617,2590],{},[66,2618,742],{"href":741},[215,2620,2621,2622],{},"XSH, System Interfaces, ",[43,2623,2624],{},"      fopen     ",[200,2626,2628,2634],{"className":2627},[2085],[215,2629,2585,2630,2590],{},[66,2631,2633],{"href":2632},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-Koenig89","Koenig 1989",[215,2635,2636],{},"Section 5.4, p. 73",[200,2638,2640,2644],{"className":2639},[2046],[215,2641,2585,2642,2590],{},[66,2643,69],{"href":68},[215,2645,2646],{},[2069,2647],{},[2649,2650],"hr",{},[39,2652,2653,229,2660,229,2665],{},[66,2654,2656],{"href":2655},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002F",[2657,2658],"img",{"src":2659},"\u002Fattachments\u002F87152044\u002F88034188.png",[66,2661,2662],{"href":2655},[2657,2663],{"src":2664},"\u002Fattachments\u002F87152044\u002F88034190.png",[66,2666,2668],{"href":2667},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr32-c",[2657,2669],{"src":2670},"\u002Fattachments\u002F87152044\u002F88034189.png",[148,2672,2674],{"id":2673},"attachments","Attachments:",[2056,2676,2680],{"className":2677,"align":2679},[2678],"greybox","left",[39,2681,2682,229,2685,2690],{},[2657,2683],{"alt":998,"src":2684},"images\u002Ficons\u002Fbullet_blue.gif",[66,2686,2689],{"href":2687,"target":2688},"\u002Fattachments\u002F87152351\u002F335675458.url","_blank","Bold.url"," (application\u002Foctet-stream)",[2692,2693,2694],"style",{},"html pre.shiki code .sC2Qs, html code.shiki .sC2Qs{--shiki-default:#D73A49;--shiki-dark:#F97583;--shiki-sepia:#F92672}html pre.shiki code .sstjo, html code.shiki .sstjo{--shiki-default:#032F62;--shiki-dark:#9ECBFF;--shiki-sepia:#E6DB74}html pre.shiki code .sMOD_, html code.shiki .sMOD_{--shiki-default:#24292E;--shiki-dark:#E1E4E8;--shiki-sepia:#F8F8F2}html pre.shiki code .sq6CD, html code.shiki .sq6CD{--shiki-default:#D73A49;--shiki-default-font-style:inherit;--shiki-dark:#F97583;--shiki-dark-font-style:inherit;--shiki-sepia:#66D9EF;--shiki-sepia-font-style:italic}html pre.shiki code .srTi1, html code.shiki .srTi1{--shiki-default:#6F42C1;--shiki-dark:#B392F0;--shiki-sepia:#A6E22E}html pre.shiki code .sTHNf, html code.shiki .sTHNf{--shiki-default:#E36209;--shiki-default-font-style:inherit;--shiki-dark:#FFAB70;--shiki-dark-font-style:inherit;--shiki-sepia:#FD971F;--shiki-sepia-font-style:italic}html pre.shiki code .s7F3e, html code.shiki .s7F3e{--shiki-default:#005CC5;--shiki-dark:#79B8FF;--shiki-sepia:#AE81FF}html pre.shiki code .s8-w5, html code.shiki .s8-w5{--shiki-default:#6A737D;--shiki-dark:#6A737D;--shiki-sepia:#88846F}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html .sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}html.sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}",{"title":998,"searchDepth":1016,"depth":1016,"links":2696},[2697,2699,2701,2703,2704,2706,2708,2710,2712,2714,2716,2718,2720,2724,2725,2729,2730],{"id":150,"depth":1016,"text":2698},"Library Functions that Set errno and Return an Out-of-Band Error Indicator",{"id":359,"depth":1016,"text":2700},"Library Functions that Set errno and Return an In-Band Error Indicator",{"id":676,"depth":1016,"text":2702},"Library Functions that Do Not Promise to Set errno",{"id":712,"depth":1016,"text":713},{"id":758,"depth":1016,"text":2705},"Library Functions and errno",{"id":960,"depth":1016,"text":2707},"Noncompliant Code Example ( strtoul() )",{"id":1205,"depth":1016,"text":2709},"Compliant Solution ( strtoul() )",{"id":1377,"depth":1016,"text":2711},"Noncompliant Code Example ( ftell() )",{"id":1483,"depth":1016,"text":2713},"Compliant Solution ( ftell() )",{"id":1578,"depth":1016,"text":2715},"Noncompliant Code Example ( fopen() )",{"id":1702,"depth":1016,"text":2717},"Compliant Solution ( fopen() , C)",{"id":1804,"depth":1016,"text":2719},"Compliant Solution ( fopen() , POSIX)",{"id":1940,"depth":1016,"text":1941,"children":2721},[2722,2723],{"id":2011,"depth":1024,"text":2012},{"id":2422,"depth":1024,"text":2423},{"id":2440,"depth":1016,"text":2441},{"id":2529,"depth":1016,"text":2530,"children":2726},[2727,2728],{"id":2539,"depth":1024,"text":2540},{"id":2554,"depth":1024,"text":2555},{"id":2564,"depth":1016,"text":2565},{"id":2673,"depth":1016,"text":2674},"The value of errno is initialized to zero at program startup, but it is never subsequently set to zero by any C standard library function. The value of errno may be set to nonzero by a C standard library function call whether or not there is an error, provided the use of errno is not documented in the description of the function. It is meaningful for a program to inspect the contents of errno only after an error might have occurred. More precisely, errno is meaningful only after a library function that sets errno on error has returned an error code.","md",{"tags":2734},[2735,2736,2737,2738,2739,2740,2741,2742],"in-cpp","ptc","err","cwe-456","rose-possible","rule","sample","android-applicable","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr30-c",{"title":30,"description":2731},"4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F2.err30-c","PzF97MMZnP185m1SMqpgNKHPzR2q6yP5Q2H6LxF7pwM",[2748,2752],{"title":2749,"path":2750,"stem":2751,"children":-1},"Error Handling (ERR)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err","4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F1.index",{"title":2753,"path":2667,"stem":2754,"children":-1},"ERR32-C. Do not rely on indeterminate values of errno","4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F3.err32-c",[2756],{"title":2757,"path":2758,"stem":2759,"children":2760},"SEI CERT C Coding Standard","\u002Fsei-cert-c-coding-standard","4.sei-cert-c-coding-standard\u002F01.index",[2761,2762,2834,3415,3691,3705,3709,3713,3717,4530],{"title":2757,"path":2758,"stem":2759},{"title":2763,"path":2764,"stem":2765,"children":2766},"Front Matter","\u002Fsei-cert-c-coding-standard\u002Ffront-matter","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F1.index",[2767,2768],{"title":2763,"path":2764,"stem":2765},{"title":2769,"path":2770,"stem":2771,"children":2772},"Introduction","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F01.index",[2773,2774,2778,2782,2786,2790,2794,2798,2802,2806,2810,2814,2818,2822,2826,2830],{"title":2769,"path":2770,"stem":2771},{"title":2775,"path":2776,"stem":2777},"Scope","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fscope","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F01.scope",{"title":2779,"path":2780,"stem":2781},"Audience","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Faudience","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F02.audience",{"title":2783,"path":2784,"stem":2785},"How this Coding Standard is Organized","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fhow-this-coding-standard-is-organized","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F03.how-this-coding-standard-is-organized",{"title":2787,"path":2788,"stem":2789},"History","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fhistory","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F04.history",{"title":2791,"path":2792,"stem":2793},"ISO\u002FIEC TS 17961 C Secure Coding Rules","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fisoiec-ts-17961-c-secure-coding-rules","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F05.isoiec-ts-17961-c-secure-coding-rules",{"title":2795,"path":2796,"stem":2797},"Tool Selection and Validation","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Ftool-selection-and-validation","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F06.tool-selection-and-validation",{"title":2799,"path":2800,"stem":2801},"Taint Analysis","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Ftaint-analysis","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F07.taint-analysis",{"title":2803,"path":2804,"stem":2805},"Rules versus Recommendations","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Frules-versus-recommendations","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F08.rules-versus-recommendations",{"title":2807,"path":2808,"stem":2809},"Conformance Testing","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fconformance-testing","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F09.conformance-testing",{"title":2811,"path":2812,"stem":2813},"Development Process","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fdevelopment-process","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F10.development-process",{"title":2815,"path":2816,"stem":2817},"Usage","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fusage","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F11.usage",{"title":2819,"path":2820,"stem":2821},"System Qualities","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fsystem-qualities","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F12.system-qualities",{"title":2823,"path":2824,"stem":2825},"Automatically Generated Code","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fautomatically-generated-code","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F13.automatically-generated-code",{"title":2827,"path":2828,"stem":2829},"Government Regulations","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fgovernment-regulations","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F14.government-regulations",{"title":2831,"path":2832,"stem":2833},"Acknowledgments","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Facknowledgments","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F15.acknowledgments",{"title":2835,"path":2836,"stem":2837,"children":2838},"Rules","\u002Fsei-cert-c-coding-standard\u002Frules","4.sei-cert-c-coding-standard\u002F03.rules\u002F01.index",[2839,2840,2844,2874,2904,2966,3004,3030,3043,3109,3135,3193,3227,3257,3267,3305,3375,3393],{"title":2835,"path":2836,"stem":2837},{"title":2841,"path":2842,"stem":2843},"Application Programming Interfaces (API)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fapplication-programming-interfaces-api","4.sei-cert-c-coding-standard\u002F03.rules\u002F02.application-programming-interfaces-api",{"title":2845,"path":2846,"stem":2847,"children":2848},"Arrays (ARR)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F1.index",[2849,2850,2854,2858,2862,2866,2870],{"title":2845,"path":2846,"stem":2847},{"title":2851,"path":2852,"stem":2853},"ARR30-C. Do not form or use out-of-bounds pointers or array subscripts","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F2.arr30-c",{"title":2855,"path":2856,"stem":2857},"ARR32-C. Ensure size arguments for variable length arrays are in a valid range","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F3.arr32-c",{"title":2859,"path":2860,"stem":2861},"ARR36-C. Do not subtract or compare two pointers that do not refer to the same array","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F4.arr36-c",{"title":2863,"path":2864,"stem":2865},"ARR37-C. Do not add or subtract an integer to a pointer to a non-array object","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F5.arr37-c",{"title":2867,"path":2868,"stem":2869},"ARR38-C. Guarantee that library functions do not form invalid pointers","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F6.arr38-c",{"title":2871,"path":2872,"stem":2873},"ARR39-C. Do not add or subtract a scaled integer to a pointer","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr\u002Farr39-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F7.arr39-c",{"title":2875,"path":2876,"stem":2877,"children":2878},"Characters and Strings (STR)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str","4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F1.index",[2879,2880,2884,2888,2892,2896,2900],{"title":2875,"path":2876,"stem":2877},{"title":2881,"path":2882,"stem":2883},"STR30-C. Do not attempt to modify string literals","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F2.str30-c",{"title":2885,"path":2886,"stem":2887},"STR31-C. Guarantee that storage for strings has sufficient space for character data and the null terminator","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr31-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F3.str31-c",{"title":2889,"path":2890,"stem":2891},"STR32-C. Do not pass a non-null-terminated character sequence to a library function that expects a string","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F4.str32-c",{"title":2893,"path":2894,"stem":2895},"STR34-C. Cast characters to unsigned char before converting to larger integer sizes","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F5.str34-c",{"title":2897,"path":2898,"stem":2899},"STR37-C. Arguments to character-handling functions must be representable as an unsigned char","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F6.str37-c",{"title":2901,"path":2902,"stem":2903},"STR38-C. Do not confuse narrow and wide character strings and functions","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F7.str38-c",{"title":2905,"path":2906,"stem":2907,"children":2908},"Concurrency (CON)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F01.index",[2909,2910,2914,2918,2922,2926,2930,2934,2938,2942,2946,2950,2954,2958,2962],{"title":2905,"path":2906,"stem":2907},{"title":2911,"path":2912,"stem":2913},"CON30-C. Clean up thread-specific storage","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F02.con30-c",{"title":2915,"path":2916,"stem":2917},"CON31-C. Do not destroy a mutex while it is locked","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon31-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F03.con31-c",{"title":2919,"path":2920,"stem":2921},"CON32-C. Prevent data races when accessing bit-fields from multiple threads","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F04.con32-c",{"title":2923,"path":2924,"stem":2925},"CON33-C. Avoid race conditions when using library functions","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F05.con33-c",{"title":2927,"path":2928,"stem":2929},"CON34-C. Declare objects shared between threads with appropriate storage durations","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F06.con34-c",{"title":2931,"path":2932,"stem":2933},"CON35-C. Avoid deadlock by locking in a predefined order","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon35-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F07.con35-c",{"title":2935,"path":2936,"stem":2937},"CON36-C. Wrap functions that can spuriously wake up in a loop","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F08.con36-c",{"title":2939,"path":2940,"stem":2941},"CON37-C. Do not call signal() in a multithreaded program","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F09.con37-c",{"title":2943,"path":2944,"stem":2945},"CON38-C. Preserve thread safety and liveness when using condition variables","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F10.con38-c",{"title":2947,"path":2948,"stem":2949},"CON39-C. Do not join or detach a thread that was previously joined or detached","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon39-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F11.con39-c",{"title":2951,"path":2952,"stem":2953},"CON40-C. Do not refer to an atomic variable twice in an expression","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon40-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F12.con40-c",{"title":2955,"path":2956,"stem":2957},"CON41-C. Wrap functions that can fail spuriously in a loop","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon41-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F13.con41-c",{"title":2959,"path":2960,"stem":2961},"CON42-C. Don't allow attackers to influence environment variables that control concurrency parameters","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon42-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F14.con42-c",{"title":2963,"path":2964,"stem":2965},"CON43-C. Do not allow data races in multithreaded code","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon43-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F15.con43-c",{"title":2967,"path":2968,"stem":2969,"children":2970},"Declarations and Initialization (DCL)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F1.index",[2971,2972,2976,2980,2984,2988,2992,2996,3000],{"title":2967,"path":2968,"stem":2969},{"title":2973,"path":2974,"stem":2975},"DCL30-C. Declare objects with appropriate storage durations","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F2.dcl30-c",{"title":2977,"path":2978,"stem":2979},"DCL31-C. Declare identifiers before using them","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl31-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F3.dcl31-c",{"title":2981,"path":2982,"stem":2983},"DCL36-C. Do not declare an identifier with conflicting linkage classifications","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F4.dcl36-c",{"title":2985,"path":2986,"stem":2987},"DCL37-C. Do not declare or define a reserved identifier","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F5.dcl37-c",{"title":2989,"path":2990,"stem":2991},"DCL38-C. Use the correct syntax when declaring a flexible array member","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F6.dcl38-c",{"title":2993,"path":2994,"stem":2995},"DCL39-C. Avoid information leakage when passing a structure across a trust boundary","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl39-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F7.dcl39-c",{"title":2997,"path":2998,"stem":2999},"DCL40-C. Do not create incompatible declarations of the same function or object","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl40-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F8.dcl40-c",{"title":3001,"path":3002,"stem":3003},"DCL41-C. Do not declare variables inside a switch statement before the first case label","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl41-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F06.declarations-and-initialization-dcl\u002F9.dcl41-c",{"title":3005,"path":3006,"stem":3007,"children":3008},"Environment (ENV)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F1.index",[3009,3010,3014,3018,3022,3026],{"title":3005,"path":3006,"stem":3007},{"title":3011,"path":3012,"stem":3013},"ENV30-C. Do not modify the object referenced by the return value of certain functions","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env\u002Fenv30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F2.env30-c",{"title":3015,"path":3016,"stem":3017},"ENV31-C. Do not rely on an environment pointer following an operation that may invalidate it","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env\u002Fenv31-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F3.env31-c",{"title":3019,"path":3020,"stem":3021},"ENV32-C. All exit handlers must return normally","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env\u002Fenv32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F4.env32-c",{"title":3023,"path":3024,"stem":3025},"ENV33-C. Do not call system()","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env\u002Fenv33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F5.env33-c",{"title":3027,"path":3028,"stem":3029},"ENV34-C. Do not store pointers returned by certain functions","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env\u002Fenv34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F6.env34-c",{"title":2749,"path":2750,"stem":2751,"children":3031},[3032,3033,3034,3035,3039],{"title":2749,"path":2750,"stem":2751},{"title":30,"path":2743,"stem":2745},{"title":2753,"path":2667,"stem":2754},{"title":3036,"path":3037,"stem":3038},"ERR33-C. Detect and handle standard library errors","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F4.err33-c",{"title":3040,"path":3041,"stem":3042},"ERR34-C. Detect errors when converting a string to a number","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F5.err34-c",{"title":3044,"path":3045,"stem":3046,"children":3047},"Expressions (EXP)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F01.index",[3048,3049,3053,3057,3061,3065,3069,3073,3077,3081,3085,3089,3093,3097,3101,3105],{"title":3044,"path":3045,"stem":3046},{"title":3050,"path":3051,"stem":3052},"EXP30-C. Do not depend on the order of evaluation for side effects","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F02.exp30-c",{"title":3054,"path":3055,"stem":3056},"EXP32-C. Do not access a volatile object through a nonvolatile reference","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F03.exp32-c",{"title":3058,"path":3059,"stem":3060},"EXP33-C. Do not read uninitialized memory","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F04.exp33-c",{"title":3062,"path":3063,"stem":3064},"EXP34-C. Do not dereference null pointers","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F05.exp34-c",{"title":3066,"path":3067,"stem":3068},"EXP35-C. Do not modify objects with temporary lifetime","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp35-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F06.exp35-c",{"title":3070,"path":3071,"stem":3072},"EXP36-C. Do not cast pointers into more strictly aligned pointer types","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F07.exp36-c",{"title":3074,"path":3075,"stem":3076},"EXP37-C. Call functions with the correct number and type of arguments","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F08.exp37-c",{"title":3078,"path":3079,"stem":3080},"EXP39-C. Do not access a variable through a pointer of an incompatible type","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp39-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F09.exp39-c",{"title":3082,"path":3083,"stem":3084},"EXP40-C. Do not modify constant objects","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp40-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F10.exp40-c",{"title":3086,"path":3087,"stem":3088},"EXP42-C. Do not compare padding data","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp42-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F11.exp42-c",{"title":3090,"path":3091,"stem":3092},"EXP43-C. Avoid undefined behavior when using restrict-qualified pointers","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp43-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F12.exp43-c",{"title":3094,"path":3095,"stem":3096},"EXP44-C. Do not rely on side effects in operands to sizeof, _Alignof, or _Generic","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp44-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F13.exp44-c",{"title":3098,"path":3099,"stem":3100},"EXP45-C. Do not perform assignments in selection statements","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp45-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F14.exp45-c",{"title":3102,"path":3103,"stem":3104},"EXP46-C. Do not use a bitwise operator with a Boolean-like operand","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp46-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F15.exp46-c",{"title":3106,"path":3107,"stem":3108},"EXP47-C. Do not call va_arg with an argument of the incorrect type","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp47-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F16.exp47-c",{"title":3110,"path":3111,"stem":3112,"children":3113},"Floating Point (FLP)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp","4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F1.index",[3114,3115,3119,3123,3127,3131],{"title":3110,"path":3111,"stem":3112},{"title":3116,"path":3117,"stem":3118},"FLP30-C. Do not use floating-point variables as loop counters","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp\u002Fflp30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F2.flp30-c",{"title":3120,"path":3121,"stem":3122},"FLP32-C. Prevent or detect domain and range errors in math functions","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp\u002Fflp32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F3.flp32-c",{"title":3124,"path":3125,"stem":3126},"FLP34-C. Ensure that floating-point conversions are within range of the new type","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp\u002Fflp34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F4.flp34-c",{"title":3128,"path":3129,"stem":3130},"FLP36-C. Preserve precision when converting integral values to floating-point type","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp\u002Fflp36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F5.flp36-c",{"title":3132,"path":3133,"stem":3134},"FLP37-C. Do not use object representations to compare floating-point values","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ffloating-point-flp\u002Fflp37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F10.floating-point-flp\u002F6.flp37-c",{"title":3136,"path":3137,"stem":3138,"children":3139},"Input Output (FIO)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F01.index",[3140,3141,3145,3149,3153,3157,3161,3165,3169,3173,3177,3181,3185,3189],{"title":3136,"path":3137,"stem":3138},{"title":3142,"path":3143,"stem":3144},"FIO30-C. Exclude user input from format strings","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F02.fio30-c",{"title":3146,"path":3147,"stem":3148},"FIO32-C. Do not perform operations on devices that are only appropriate for files","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F03.fio32-c",{"title":3150,"path":3151,"stem":3152},"FIO34-C. Distinguish between characters read from a file and EOF or WEOF","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F04.fio34-c",{"title":3154,"path":3155,"stem":3156},"FIO37-C. Do not assume that fgets() or fgetws() returns a nonempty string when successful","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F05.fio37-c",{"title":3158,"path":3159,"stem":3160},"FIO38-C. Do not copy a FILE object","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F06.fio38-c",{"title":3162,"path":3163,"stem":3164},"FIO39-C. Do not alternately input and output from a stream without an intervening flush or positioning call","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio39-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F07.fio39-c",{"title":3166,"path":3167,"stem":3168},"FIO40-C. Reset strings on fgets() or fgetws() failure","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio40-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F08.fio40-c",{"title":3170,"path":3171,"stem":3172},"FIO41-C. Do not call getc(), putc(), getwc(), or putwc() with a stream argument that has side effects","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio41-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F09.fio41-c",{"title":3174,"path":3175,"stem":3176},"FIO42-C. Close files when they are no longer needed","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio42-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F10.fio42-c",{"title":3178,"path":3179,"stem":3180},"FIO44-C. Only use values for fsetpos() that are returned from fgetpos()","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio44-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F11.fio44-c",{"title":3182,"path":3183,"stem":3184},"FIO45-C. Avoid TOCTOU race conditions while accessing files","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio45-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F12.fio45-c",{"title":3186,"path":3187,"stem":3188},"FIO46-C. Do not access a closed file","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio46-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F13.fio46-c",{"title":3190,"path":3191,"stem":3192},"FIO47-C. Use valid format strings","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio47-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F14.fio47-c",{"title":3194,"path":3195,"stem":3196,"children":3197},"Integers (INT)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F1.index",[3198,3199,3203,3207,3211,3215,3219,3223],{"title":3194,"path":3195,"stem":3196},{"title":3200,"path":3201,"stem":3202},"INT30-C. Ensure that unsigned integer operations do not wrap","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F2.int30-c",{"title":3204,"path":3205,"stem":3206},"INT31-C. Ensure that integer conversions do not result in lost or misinterpreted data","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint31-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F3.int31-c",{"title":3208,"path":3209,"stem":3210},"INT32-C. Ensure that operations on signed integers do not result in overflow","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F4.int32-c",{"title":3212,"path":3213,"stem":3214},"INT33-C. Ensure that division and remainder operations do not result in divide-by-zero errors","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F5.int33-c",{"title":3216,"path":3217,"stem":3218},"INT34-C. Do not shift an expression by a negative number of bits or by greater than or equal to the number of bits that exist in the operand","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F6.int34-c",{"title":3220,"path":3221,"stem":3222},"INT35-C. Use correct integer precisions","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint35-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F7.int35-c",{"title":3224,"path":3225,"stem":3226},"INT36-C. Converting a pointer to integer or integer to pointer","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F8.int36-c",{"title":3228,"path":3229,"stem":3230,"children":3231},"Memory Management (MEM)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem","4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F1.index",[3232,3233,3237,3241,3245,3249,3253],{"title":3228,"path":3229,"stem":3230},{"title":3234,"path":3235,"stem":3236},"MEM30-C. Do not access freed memory","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F2.mem30-c",{"title":3238,"path":3239,"stem":3240},"MEM31-C. Free dynamically allocated memory when no longer needed","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem31-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F3.mem31-c",{"title":3242,"path":3243,"stem":3244},"MEM33-C. Allocate and copy structures containing a flexible array member dynamically","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F4.mem33-c",{"title":3246,"path":3247,"stem":3248},"MEM34-C. Only free memory allocated dynamically","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F5.mem34-c",{"title":3250,"path":3251,"stem":3252},"MEM35-C. Allocate sufficient memory for an object","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem35-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F6.mem35-c",{"title":3254,"path":3255,"stem":3256},"MEM36-C. Do not modify the alignment of objects by calling realloc()","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F13.memory-management-mem\u002F7.mem36-c",{"title":3258,"path":3259,"stem":3260,"children":3261},"Microsoft Windows (WIN)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmicrosoft-windows-win","4.sei-cert-c-coding-standard\u002F03.rules\u002F14.microsoft-windows-win\u002F1.index",[3262,3263],{"title":3258,"path":3259,"stem":3260},{"title":3264,"path":3265,"stem":3266},"WIN30-C. Properly pair allocation and deallocation functions","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmicrosoft-windows-win\u002Fwin30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F14.microsoft-windows-win\u002F2.win30-c",{"title":3268,"path":3269,"stem":3270,"children":3271},"Miscellaneous (MSC)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F1.index",[3272,3273,3277,3281,3285,3289,3293,3297,3301],{"title":3268,"path":3269,"stem":3270},{"title":3274,"path":3275,"stem":3276},"MSC30-C. Do not use the rand() function for generating pseudorandom numbers","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F2.msc30-c",{"title":3278,"path":3279,"stem":3280},"MSC32-C. Properly seed pseudorandom number generators","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F3.msc32-c",{"title":3282,"path":3283,"stem":3284},"MSC33-C. Do not pass invalid data to the asctime() function","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc33-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F4.msc33-c",{"title":3286,"path":3287,"stem":3288},"MSC37-C. Ensure that control never reaches the end of a non-void function","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F5.msc37-c",{"title":3290,"path":3291,"stem":3292},"MSC38-C. Do not treat a predefined identifier as an object if it might only be implemented as a macro","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F6.msc38-c",{"title":3294,"path":3295,"stem":3296},"MSC39-C. Do not call va_arg() on a va_list that has an indeterminate value","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc39-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F7.msc39-c",{"title":3298,"path":3299,"stem":3300},"MSC40-C. Do not violate constraints","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc40-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F8.msc40-c",{"title":3302,"path":3303,"stem":3304},"MSC41-C. Never hard code sensitive information","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc41-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F9.msc41-c",{"title":3306,"path":3307,"stem":3308,"children":3309},"POSIX (POS)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F01.index",[3310,3311,3315,3319,3323,3327,3331,3335,3339,3343,3347,3351,3355,3359,3363,3367,3371],{"title":3306,"path":3307,"stem":3308},{"title":3312,"path":3313,"stem":3314},"POS30-C. Use the readlink() function properly","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F02.pos30-c",{"title":3316,"path":3317,"stem":3318},"POS34-C. Do not call putenv() with a pointer to an automatic variable as the argument","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F03.pos34-c",{"title":3320,"path":3321,"stem":3322},"POS35-C. Avoid race conditions while checking for the existence of a symbolic link","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos35-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F04.pos35-c",{"title":3324,"path":3325,"stem":3326},"POS36-C. Observe correct revocation order while relinquishing privileges","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos36-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F05.pos36-c",{"title":3328,"path":3329,"stem":3330},"POS37-C. Ensure that privilege relinquishment is successful","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos37-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F06.pos37-c",{"title":3332,"path":3333,"stem":3334},"POS38-C. Beware of race conditions when using fork and file descriptors","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos38-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F07.pos38-c",{"title":3336,"path":3337,"stem":3338},"POS39-C. Use the correct byte ordering when transferring data between systems","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos39-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F08.pos39-c",{"title":3340,"path":3341,"stem":3342},"POS44-C. Do not use signals to terminate threads","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos44-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F09.pos44-c",{"title":3344,"path":3345,"stem":3346},"POS47-C. Do not use threads that can be canceled asynchronously","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos47-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F10.pos47-c",{"title":3348,"path":3349,"stem":3350},"POS48-C. Do not unlock or destroy another POSIX thread's mutex","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos48-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F11.pos48-c",{"title":3352,"path":3353,"stem":3354},"POS49-C. When data must be accessed by multiple threads, provide a mutex and guarantee no adjacent data is also accessed","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos49-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F12.pos49-c",{"title":3356,"path":3357,"stem":3358},"POS50-C. Declare objects shared between POSIX threads with appropriate storage durations","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos50-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F13.pos50-c",{"title":3360,"path":3361,"stem":3362},"POS51-C. Avoid deadlock with POSIX threads by locking in predefined order","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos51-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F14.pos51-c",{"title":3364,"path":3365,"stem":3366},"POS52-C. Do not perform operations that can block while holding a POSIX lock","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos52-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F15.pos52-c",{"title":3368,"path":3369,"stem":3370},"POS53-C. Do not use more than one mutex for concurrent waiting operations on a condition variable","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos53-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F16.pos53-c",{"title":3372,"path":3373,"stem":3374},"POS54-C. Detect and handle POSIX library errors","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos\u002Fpos54-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F17.pos54-c",{"title":3376,"path":3377,"stem":3378,"children":3379},"Preprocessor (PRE)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre","4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F1.index",[3380,3381,3385,3389],{"title":3376,"path":3377,"stem":3378},{"title":3382,"path":3383,"stem":3384},"PRE30-C. Do not create a universal character name through concatenation","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F2.pre30-c",{"title":3386,"path":3387,"stem":3388},"PRE31-C. Avoid side effects in arguments to unsafe macros","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre31-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F3.pre31-c",{"title":3390,"path":3391,"stem":3392},"PRE32-C. Do not use preprocessor directives in invocations of function-like macros","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre\u002Fpre32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F4.pre32-c",{"title":3394,"path":3395,"stem":3396,"children":3397},"Signals (SIG)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig","4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F1.index",[3398,3399,3403,3407,3411],{"title":3394,"path":3395,"stem":3396},{"title":3400,"path":3401,"stem":3402},"SIG30-C. Call only asynchronous-safe functions within signal handlers","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig\u002Fsig30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F2.sig30-c",{"title":3404,"path":3405,"stem":3406},"SIG31-C. Do not access shared objects in signal handlers","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig\u002Fsig31-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F3.sig31-c",{"title":3408,"path":3409,"stem":3410},"SIG34-C. Do not call signal() from within interruptible signal handlers","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig\u002Fsig34-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F4.sig34-c",{"title":3412,"path":3413,"stem":3414},"SIG35-C. Do not return from a computational exception signal handler","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig\u002Fsig35-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F5.sig35-c",{"title":3416,"path":3417,"stem":3418,"children":3419},"Back Matter","\u002Fsei-cert-c-coding-standard\u002Fback-matter","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F1.index",[3420,3421,3425,3429,3433,3437,3630,3687],{"title":3416,"path":3417,"stem":3418},{"title":3422,"path":3423,"stem":3424},"AA. Bibliography","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Faa-bibliography","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F2.aa-bibliography",{"title":3426,"path":3427,"stem":3428},"BB. Definitions","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F3.bb-definitions",{"title":3430,"path":3431,"stem":3432},"CC. Undefined Behavior","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fcc-undefined-behavior","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F4.cc-undefined-behavior",{"title":3434,"path":3435,"stem":3436},"DD. Unspecified Behavior","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fdd-unspecified-behavior","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F5.dd-unspecified-behavior",{"title":3438,"path":3439,"stem":3440,"children":3441},"EE. Analyzers","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F01.index",[3442,3443,3445,3449,3451,3455,3459,3463,3467,3471,3475,3479,3483,3485,3489,3491,3495,3499,3501,3505,3509,3513,3517,3521,3525,3529,3533,3535,3539,3541,3545,3548,3552,3555,3559,3563,3567,3569,3573,3577,3581,3584,3588,3592,3594,3598,3602,3606,3610,3614,3618,3622,3626],{"title":3438,"path":3439,"stem":3440},{"title":2052,"path":2051,"stem":3444},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F02.astree",{"title":3446,"path":3447,"stem":3448},"Astrée_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fastree_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F03.astree_v",{"title":2091,"path":2090,"stem":3450},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F04.axivion-bauhaus-suite",{"title":3452,"path":3453,"stem":3454},"Axivion Bauhaus Suite_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Faxivion-bauhaus-suite_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F05.axivion-bauhaus-suite_v",{"title":3456,"path":3457,"stem":3458},"Clang","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fclang","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F06.clang",{"title":3460,"path":3461,"stem":3462},"Clang_38_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fclang_38_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F07.clang_38_v",{"title":3464,"path":3465,"stem":3466},"Clang_39_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fclang_39_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F08.clang_39_v",{"title":3468,"path":3469,"stem":3470},"Clang_40_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fclang_40_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F09.clang_40_v",{"title":3472,"path":3473,"stem":3474},"Clang_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fclang_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F10.clang_v",{"title":3476,"path":3477,"stem":3478},"Codee","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcodee","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F11.codee",{"title":3480,"path":3481,"stem":3482},"Codee_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcodee_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F12.codee_v",{"title":2116,"path":2115,"stem":3484},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F13.codesonar",{"title":3486,"path":3487,"stem":3488},"CodeSonar_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcodesonar_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F14.codesonar_v",{"title":2168,"path":2167,"stem":3490},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F15.coverity",{"title":3492,"path":3493,"stem":3494},"Coverity_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcoverity_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F16.coverity_v",{"title":3496,"path":3497,"stem":3498},"Cppcheck","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcppcheck","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F17.cppcheck",{"title":2209,"path":2208,"stem":3500},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F18.cppcheck-premium",{"title":3502,"path":3503,"stem":3504},"Cppcheck Premium_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcppcheck-premium_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F19.cppcheck-premium_v",{"title":3506,"path":3507,"stem":3508},"Cppcheck_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcppcheck_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F20.cppcheck_v",{"title":3510,"path":3511,"stem":3512},"ECLAIR","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Feclair","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F21.eclair",{"title":3514,"path":3515,"stem":3516},"ECLAIR_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Feclair_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F22.eclair_v",{"title":3518,"path":3519,"stem":3520},"EDG","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fedg","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F23.edg",{"title":3522,"path":3523,"stem":3524},"EDG_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fedg_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F24.edg_v",{"title":3526,"path":3527,"stem":3528},"GCC","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fgcc","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F25.gcc",{"title":3530,"path":3531,"stem":3532},"GCC_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fgcc_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F26.gcc_v",{"title":2235,"path":2234,"stem":3534},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F27.helix-qac",{"title":3536,"path":3537,"stem":3538},"Helix QAC_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fhelix-qac_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F28.helix-qac_v",{"title":2268,"path":2267,"stem":3540},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F29.klocwork",{"title":3542,"path":3543,"stem":3544},"Klocwork_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fklocwork_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F30.klocwork_v",{"title":3546,"path":2302,"stem":3547},"LDRA","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F31.ldra",{"title":3549,"path":3550,"stem":3551},"LDRA_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fldra_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F32.ldra_v",{"title":3553,"path":2328,"stem":3554},"Parasoft","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F33.parasoft",{"title":3556,"path":3557,"stem":3558},"Parasoft_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fparasoft_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F34.parasoft_v",{"title":3560,"path":3561,"stem":3562},"PC-lint Plus","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpc-lint-plus","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F35.pc-lint-plus",{"title":3564,"path":3565,"stem":3566},"PC-lint Plus_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpc-lint-plus_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F36.pc-lint-plus_v",{"title":2357,"path":2356,"stem":3568},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F37.polyspace-bug-finder",{"title":3570,"path":3571,"stem":3572},"Polyspace Bug Finder_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpolyspace-bug-finder_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F38.polyspace-bug-finder_v",{"title":3574,"path":3575,"stem":3576},"PVS-Studio","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpvs-studio","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F39.pvs-studio",{"title":3578,"path":3579,"stem":3580},"PVS-Studio_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpvs-studio_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F40.pvs-studio_v",{"title":3582,"path":2142,"stem":3583},"Rose","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F41.rose",{"title":3585,"path":3586,"stem":3587},"Rose_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Frose_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F42.rose_v",{"title":3589,"path":3590,"stem":3591},"Rosecheckers Code","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Frosecheckers-code","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F43.rosecheckers-code",{"title":2402,"path":2401,"stem":3593},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F44.rulechecker",{"title":3595,"path":3596,"stem":3597},"RuleChecker_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Frulechecker_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F45.rulechecker_v",{"title":3599,"path":3600,"stem":3601},"Security Reviewer - Static Reviewer","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsecurity-reviewer-static-reviewer","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F46.security-reviewer-static-reviewer",{"title":3603,"path":3604,"stem":3605},"Security Reviewer - Static Reviewer_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsecurity-reviewer-static-reviewer_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F47.security-reviewer-static-reviewer_v",{"title":3607,"path":3608,"stem":3609},"SonarQube C\u002FC++ Plugin","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsonarqube-ccpp-plugin","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F48.sonarqube-ccpp-plugin",{"title":3611,"path":3612,"stem":3613},"SonarQube C\u002FC++ Plugin_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsonarqube-ccpp-plugin_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F49.sonarqube-ccpp-plugin_v",{"title":3615,"path":3616,"stem":3617},"Splint","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsplint","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F50.splint",{"title":3619,"path":3620,"stem":3621},"Splint_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsplint_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F51.splint_v",{"title":3623,"path":3624,"stem":3625},"TrustInSoft Analyzer","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Ftrustinsoft-analyzer","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F52.trustinsoft-analyzer",{"title":3627,"path":3628,"stem":3629},"TrustInSoft Analyzer_V","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Ftrustinsoft-analyzer_v","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F53.trustinsoft-analyzer_v",{"title":3631,"path":3632,"stem":3633,"children":3634},"FF. Related Guidelines","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F01.index",[3635,3636,3640,3644,3648,3652,3656,3660,3664,3668,3671,3675,3679,3683],{"title":3631,"path":3632,"stem":3633},{"title":3637,"path":3638,"stem":3639},"2003","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F02.2003","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F02.2003",{"title":3641,"path":3642,"stem":3643},"2006","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F03.2006","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F03.2006",{"title":3645,"path":3646,"stem":3647},"2007","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F04.2007","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F04.2007",{"title":3649,"path":3650,"stem":3651},"2008","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F05.2008","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F05.2008",{"title":3653,"path":3654,"stem":3655},"2010","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F06.2010","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F06.2010",{"title":3657,"path":3658,"stem":3659},"2011","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F07.2011","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F07.2011",{"title":3661,"path":3662,"stem":3663},"2012","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F08.2012","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F08.2012",{"title":3665,"path":3666,"stem":3667},"2013","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F09.2013","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F09.2013",{"title":3665,"path":3669,"stem":3670},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002F10.2013","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F10.2013",{"title":3672,"path":3673,"stem":3674},"MITRE CWE","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002Fmitre-cwe","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F11.mitre-cwe",{"title":3676,"path":3677,"stem":3678},"MITRE CWE 2.11","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002Fmitre-cwe-211","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F12.mitre-cwe-211",{"title":3680,"path":3681,"stem":3682},"MITRE CWE 3.1","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002Fmitre-cwe-31","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F13.mitre-cwe-31",{"title":3684,"path":3685,"stem":3686},"MITRE CWE 3.11","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fff-related-guidelines\u002Fmitre-cwe-311","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F7.ff-related-guidelines\u002F14.mitre-cwe-311",{"title":3688,"path":3689,"stem":3690},"GG. Risk Assessments","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fgg-risk-assessments","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F8.gg-risk-assessments",{"title":3692,"path":3693,"stem":3694,"children":3695},"Admin","\u002Fsei-cert-c-coding-standard\u002Fadmin","4.sei-cert-c-coding-standard\u002F05.admin\u002F1.index",[3696,3697,3701],{"title":3692,"path":3693,"stem":3694},{"title":3698,"path":3699,"stem":3700},"TODO List","\u002Fsei-cert-c-coding-standard\u002Fadmin\u002Ftodo-list","4.sei-cert-c-coding-standard\u002F05.admin\u002F2.todo-list",{"title":3702,"path":3703,"stem":3704},"Undefined and implementation-defined behaviors not deemed ruleworthy","\u002Fsei-cert-c-coding-standard\u002Fadmin\u002Fundefined-and-implementation-defined-behaviors-not-deemed-ruleworthy","4.sei-cert-c-coding-standard\u002F05.admin\u002F3.undefined-and-implementation-defined-behaviors-not-deemed-ruleworthy",{"title":3706,"path":3707,"stem":3708},"Coding Style Guidelines","\u002Fsei-cert-c-coding-standard\u002Fcoding-style-guidelines","4.sei-cert-c-coding-standard\u002F05.coding-style-guidelines",{"title":3710,"path":3711,"stem":3712},"Errata for SEI CERT C Coding Standard (2016 Edition)","\u002Fsei-cert-c-coding-standard\u002Ferrata-for-sei-cert-c-coding-standard-2016-edition","4.sei-cert-c-coding-standard\u002F06.errata-for-sei-cert-c-coding-standard-2016-edition",{"title":3714,"path":3715,"stem":3716},"Wiki Contents","\u002Fsei-cert-c-coding-standard\u002Fwiki-contents","4.sei-cert-c-coding-standard\u002F06.wiki-contents",{"title":3718,"path":3719,"stem":3720,"children":3721},"Recommendations","\u002Fsei-cert-c-coding-standard\u002Frecommendations","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F01.index",[3722,3723,3764,3781,3826,3867,3964,3981,4014,4081,4118,4203,4268,4317,4342,4435,4456,4513],{"title":3718,"path":3719,"stem":3720},{"title":2841,"path":3724,"stem":3725,"children":3726},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F01.index",[3727,3728,3732,3736,3740,3744,3748,3752,3756,3760],{"title":2841,"path":3724,"stem":3725},{"title":3729,"path":3730,"stem":3731},"API00-C. Functions should validate their parameters","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F02.api00-c",{"title":3733,"path":3734,"stem":3735},"API01-C. Avoid laying out strings in memory directly before sensitive data","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F03.api01-c",{"title":3737,"path":3738,"stem":3739},"API02-C. Functions that read or write to or from an array should take an argument to specify the source or target size","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F04.api02-c",{"title":3741,"path":3742,"stem":3743},"API03-C. Create consistent interfaces and capabilities across related functions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F05.api03-c",{"title":3745,"path":3746,"stem":3747},"API04-C. Provide a consistent and usable error-checking mechanism","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F06.api04-c",{"title":3749,"path":3750,"stem":3751},"API05-C. Use conformant array parameters","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F07.api05-c",{"title":3753,"path":3754,"stem":3755},"API07-C. Enforce type safety","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F08.api07-c",{"title":3757,"path":3758,"stem":3759},"API09-C. Compatible values should have the same type","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi09-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F09.api09-c",{"title":3761,"path":3762,"stem":3763},"API10-C. APIs should have security options enabled by default","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fapplication-programming-interfaces-api\u002Fapi10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F02.application-programming-interfaces-api\u002F10.api10-c",{"title":2845,"path":3765,"stem":3766,"children":3767},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Farrays-arr","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F03.arrays-arr\u002F1.index",[3768,3769,3773,3777],{"title":2845,"path":3765,"stem":3766},{"title":3770,"path":3771,"stem":3772},"ARR00-C. Understand how arrays work","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Farrays-arr\u002Farr00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F03.arrays-arr\u002F2.arr00-c",{"title":3774,"path":3775,"stem":3776},"ARR01-C. Do not apply the sizeof operator to a pointer when taking the size of an array","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Farrays-arr\u002Farr01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F03.arrays-arr\u002F3.arr01-c",{"title":3778,"path":3779,"stem":3780},"ARR02-C. Explicitly specify array bounds, even if implicitly defined by an initializer","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Farrays-arr\u002Farr02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F03.arrays-arr\u002F4.arr02-c",{"title":2875,"path":3782,"stem":3783,"children":3784},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F01.index",[3785,3786,3790,3794,3798,3802,3806,3810,3814,3818,3822],{"title":2875,"path":3782,"stem":3783},{"title":3787,"path":3788,"stem":3789},"STR00-C. Represent characters using an appropriate type","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F02.str00-c",{"title":3791,"path":3792,"stem":3793},"STR01-C. Adopt and implement a consistent plan for managing strings","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F03.str01-c",{"title":3795,"path":3796,"stem":3797},"STR02-C. Sanitize data passed to complex subsystems","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F04.str02-c",{"title":3799,"path":3800,"stem":3801},"STR03-C. Do not inadvertently truncate a string","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F05.str03-c",{"title":3803,"path":3804,"stem":3805},"STR04-C. Use plain char for characters in the basic character set","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F06.str04-c",{"title":3807,"path":3808,"stem":3809},"STR05-C. Use pointers to const when referring to string literals","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F07.str05-c",{"title":3811,"path":3812,"stem":3813},"STR06-C. Do not assume that strtok() leaves the parse string unchanged","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F08.str06-c",{"title":3815,"path":3816,"stem":3817},"STR09-C. Don't assume numeric values for expressions with type plain character","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr09-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F09.str09-c",{"title":3819,"path":3820,"stem":3821},"STR10-C. Do not concatenate different type of string literals","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F10.str10-c",{"title":3823,"path":3824,"stem":3825},"STR11-C. Do not specify the bound of a character array initialized with a string literal","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr11-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F11.str11-c",{"title":2905,"path":3827,"stem":3828,"children":3829},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F01.index",[3830,3831,3835,3839,3843,3847,3851,3855,3859,3863],{"title":2905,"path":3827,"stem":3828},{"title":3832,"path":3833,"stem":3834},"CON01-C. Acquire and release synchronization primitives in the same module, at the same level of abstraction","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F02.con01-c",{"title":3836,"path":3837,"stem":3838},"CON02-C. Do not use volatile as a synchronization primitive","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F03.con02-c",{"title":3840,"path":3841,"stem":3842},"CON03-C. Ensure visibility when accessing shared variables","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F04.con03-c",{"title":3844,"path":3845,"stem":3846},"CON04-C. Join or detach threads even if their exit status is unimportant","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F05.con04-c",{"title":3848,"path":3849,"stem":3850},"CON05-C. Do not perform operations that can block while holding a lock","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F06.con05-c",{"title":3852,"path":3853,"stem":3854},"CON06-C. Ensure that every mutex outlives the data it protects","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F07.con06-c",{"title":3856,"path":3857,"stem":3858},"CON07-C. Ensure that compound operations on shared variables are atomic","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F08.con07-c",{"title":3860,"path":3861,"stem":3862},"CON08-C. Do not assume that a group of calls to independently atomic methods is atomic","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon08-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F09.con08-c",{"title":3864,"path":3865,"stem":3866},"CON09-C. Avoid the ABA problem when using lock-free algorithms","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con\u002Fcon09-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F10.con09-c",{"title":2967,"path":3868,"stem":3869,"children":3870},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F01.index",[3871,3872,3876,3880,3884,3888,3892,3896,3900,3904,3908,3912,3916,3920,3924,3928,3932,3936,3940,3944,3948,3952,3956,3960],{"title":2967,"path":3868,"stem":3869},{"title":3873,"path":3874,"stem":3875},"DCL00-C. Const-qualify immutable objects","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F02.dcl00-c",{"title":3877,"path":3878,"stem":3879},"DCL01-C. Do not reuse variable names in subscopes","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F03.dcl01-c",{"title":3881,"path":3882,"stem":3883},"DCL02-C. Use visually distinct identifiers","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F04.dcl02-c",{"title":3885,"path":3886,"stem":3887},"DCL03-C. Use a static assertion to test the value of a constant expression","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F05.dcl03-c",{"title":3889,"path":3890,"stem":3891},"DCL04-C. Do not declare more than one variable per declaration","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F06.dcl04-c",{"title":3893,"path":3894,"stem":3895},"DCL05-C. Use typedefs of non-pointer types only","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F07.dcl05-c",{"title":3897,"path":3898,"stem":3899},"DCL06-C. Use meaningful symbolic constants to represent literal values","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F08.dcl06-c",{"title":3901,"path":3902,"stem":3903},"DCL07-C. Include the appropriate type information in function declarators","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F09.dcl07-c",{"title":3905,"path":3906,"stem":3907},"DCL08-C. Properly encode relationships in constant definitions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl08-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F10.dcl08-c",{"title":3909,"path":3910,"stem":3911},"DCL09-C. Declare functions that return errno with a return type of errno_t","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl09-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F11.dcl09-c",{"title":3913,"path":3914,"stem":3915},"DCL10-C. Maintain the contract between the writer and caller of variadic functions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F12.dcl10-c",{"title":3917,"path":3918,"stem":3919},"DCL11-C. Understand the type issues associated with variadic functions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl11-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F13.dcl11-c",{"title":3921,"path":3922,"stem":3923},"DCL12-C. Implement abstract data types using opaque types","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl12-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F14.dcl12-c",{"title":3925,"path":3926,"stem":3927},"DCL13-C. Declare function parameters that are pointers to values not changed by the function as const","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl13-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F15.dcl13-c",{"title":3929,"path":3930,"stem":3931},"DCL15-C. Declare file-scope objects or functions that do not need external linkage as static","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl15-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F16.dcl15-c",{"title":3933,"path":3934,"stem":3935},"DCL16-C. Use \"L,\" not \"l,\" to indicate a long value","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl16-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F17.dcl16-c",{"title":3937,"path":3938,"stem":3939},"DCL17-C. Beware of miscompiled volatile-qualified variables","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl17-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F18.dcl17-c",{"title":3941,"path":3942,"stem":3943},"DCL18-C. Do not begin integer constants with 0 when specifying a decimal value","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl18-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F19.dcl18-c",{"title":3945,"path":3946,"stem":3947},"DCL19-C. Minimize the scope of variables and functions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl19-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F20.dcl19-c",{"title":3949,"path":3950,"stem":3951},"DCL20-C. Explicitly specify void when a function accepts no arguments","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl20-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F21.dcl20-c",{"title":3953,"path":3954,"stem":3955},"DCL21-C. Understand the storage of compound literals","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl21-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F22.dcl21-c",{"title":3957,"path":3958,"stem":3959},"DCL22-C. Use volatile for data that cannot be cached","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl22-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F23.dcl22-c",{"title":3961,"path":3962,"stem":3963},"DCL23-C. Guarantee that mutually visible identifiers are unique","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl23-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F06.declarations-and-initialization-dcl\u002F24.dcl23-c",{"title":3005,"path":3965,"stem":3966,"children":3967},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fenvironment-env","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F07.environment-env\u002F1.index",[3968,3969,3973,3977],{"title":3005,"path":3965,"stem":3966},{"title":3970,"path":3971,"stem":3972},"ENV01-C. Do not make assumptions about the size of an environment variable","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fenvironment-env\u002Fenv01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F07.environment-env\u002F2.env01-c",{"title":3974,"path":3975,"stem":3976},"ENV02-C. Beware of multiple environment variables with the same effective name","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fenvironment-env\u002Fenv02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F07.environment-env\u002F3.env02-c",{"title":3978,"path":3979,"stem":3980},"ENV03-C. Sanitize the environment when invoking external programs","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fenvironment-env\u002Fenv03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F07.environment-env\u002F4.env03-c",{"title":2749,"path":3982,"stem":3983,"children":3984},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F1.index",[3985,3986,3990,3994,3998,4002,4006,4010],{"title":2749,"path":3982,"stem":3983},{"title":3987,"path":3988,"stem":3989},"ERR00-C. Adopt and implement a consistent and comprehensive error-handling policy","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F2.err00-c",{"title":3991,"path":3992,"stem":3993},"ERR01-C. Use ferror() rather than errno to check for FILE stream errors","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F3.err01-c",{"title":3995,"path":3996,"stem":3997},"ERR02-C. Avoid in-band error indicators","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F4.err02-c",{"title":3999,"path":4000,"stem":4001},"ERR04-C. Choose an appropriate termination strategy","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F5.err04-c",{"title":4003,"path":4004,"stem":4005},"ERR05-C. Application-independent code should provide error detection without dictating error handling","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F6.err05-c",{"title":4007,"path":4008,"stem":4009},"ERR06-C. Understand the termination behavior of assert() and abort()","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F7.err06-c",{"title":4011,"path":4012,"stem":4013},"ERR07-C. Prefer functions that support error checking over equivalent functions that don't","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F8.err07-c",{"title":3044,"path":4015,"stem":4016,"children":4017},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F01.index",[4018,4019,4023,4027,4031,4035,4039,4043,4047,4051,4055,4057,4061,4065,4069,4073,4077],{"title":3044,"path":4015,"stem":4016},{"title":4020,"path":4021,"stem":4022},"EXP00-C. Use parentheses for precedence of operation","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F02.exp00-c",{"title":4024,"path":4025,"stem":4026},"EXP02-C. Be aware of the short-circuit behavior of the logical AND and OR operators","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F03.exp02-c",{"title":4028,"path":4029,"stem":4030},"EXP03-C. Do not assume the size of a structure is the sum of the sizes of its members","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F04.exp03-c",{"title":4032,"path":4033,"stem":4034},"EXP05-C. Do not cast away a const qualification","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F05.exp05-c",{"title":4036,"path":4037,"stem":4038},"EXP07-C. Do not diminish the benefits of constants by assuming their values in expressions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F06.exp07-c",{"title":4040,"path":4041,"stem":4042},"EXP08-C. Ensure pointer arithmetic is used correctly","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp08-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F07.exp08-c",{"title":4044,"path":4045,"stem":4046},"EXP09-C. Use sizeof to determine the size of a type or variable","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp09-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F08.exp09-c",{"title":4048,"path":4049,"stem":4050},"EXP10-C. Do not depend on the order of evaluation of subexpressions or the order in which side effects take place","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F09.exp10-c",{"title":4052,"path":4053,"stem":4054},"EXP11-C. Do not make assumptions regarding the layout of structures with bit-fields","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp11-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F10.exp11-c",{"title":2487,"path":2486,"stem":4056},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F11.exp12-c",{"title":4058,"path":4059,"stem":4060},"EXP13-C. Treat relational and equality operators as if they were nonassociative","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp13-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F12.exp13-c",{"title":4062,"path":4063,"stem":4064},"EXP14-C. Beware of integer promotion when performing bitwise operations on integer types smaller than int","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp14-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F13.exp14-c",{"title":4066,"path":4067,"stem":4068},"EXP15-C. Do not place a semicolon on the same line as an if, for, or while statement","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp15-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F14.exp15-c",{"title":4070,"path":4071,"stem":4072},"EXP16-C. Do not compare function pointers to constant values","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp16-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F15.exp16-c",{"title":4074,"path":4075,"stem":4076},"EXP19-C. Use braces for the body of an if, for, or while statement","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp19-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F16.exp19-c",{"title":4078,"path":4079,"stem":4080},"EXP20-C. Perform explicit tests to determine success, true and false, and equality","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp20-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F17.exp20-c",{"title":3110,"path":4082,"stem":4083,"children":4084},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F1.index",[4085,4086,4090,4094,4098,4102,4106,4110,4114],{"title":3110,"path":4082,"stem":4083},{"title":4087,"path":4088,"stem":4089},"FLP00-C. Understand the limitations of floating-point numbers","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F2.flp00-c",{"title":4091,"path":4092,"stem":4093},"FLP01-C. Take care in rearranging floating-point expressions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F3.flp01-c",{"title":4095,"path":4096,"stem":4097},"FLP02-C. Avoid using floating-point numbers when precise computation is needed","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F4.flp02-c",{"title":4099,"path":4100,"stem":4101},"FLP03-C. Detect and handle floating-point errors","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F5.flp03-c",{"title":4103,"path":4104,"stem":4105},"FLP04-C. Check floating-point inputs for exceptional values","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F6.flp04-c",{"title":4107,"path":4108,"stem":4109},"FLP05-C. Do not use denormalized numbers","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F7.flp05-c",{"title":4111,"path":4112,"stem":4113},"FLP06-C. Convert integers to floating point for floating-point operations","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F8.flp06-c",{"title":4115,"path":4116,"stem":4117},"FLP07-C. Cast the return value of a function that returns a floating-point type","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp\u002Fflp07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F9.flp07-c",{"title":3136,"path":4119,"stem":4120,"children":4121},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F01.index",[4122,4123,4127,4131,4135,4139,4143,4147,4151,4155,4159,4163,4167,4171,4175,4179,4183,4187,4191,4195,4199],{"title":3136,"path":4119,"stem":4120},{"title":4124,"path":4125,"stem":4126},"FIO01-C. Be careful using functions that use file names for identification","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F02.fio01-c",{"title":4128,"path":4129,"stem":4130},"FIO02-C. Canonicalize path names originating from tainted sources","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F03.fio02-c",{"title":4132,"path":4133,"stem":4134},"FIO03-C. Do not make assumptions about fopen() and file creation","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F04.fio03-c",{"title":4136,"path":4137,"stem":4138},"FIO05-C. Identify files using multiple file attributes","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F05.fio05-c",{"title":4140,"path":4141,"stem":4142},"FIO06-C. Create files with appropriate access permissions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F06.fio06-c",{"title":4144,"path":4145,"stem":4146},"FIO08-C. Take care when calling remove() on an open file","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio08-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F07.fio08-c",{"title":4148,"path":4149,"stem":4150},"FIO09-C. Be careful with binary data when transferring data across systems","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio09-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F08.fio09-c",{"title":4152,"path":4153,"stem":4154},"FIO10-C. Take care when using the rename() function","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F09.fio10-c",{"title":4156,"path":4157,"stem":4158},"FIO11-C. Take care when specifying the mode parameter of fopen()","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio11-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F10.fio11-c",{"title":4160,"path":4161,"stem":4162},"FIO13-C. Never push back anything other than one read character","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio13-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F11.fio13-c",{"title":4164,"path":4165,"stem":4166},"FIO14-C. Understand the difference between text mode and binary mode with file streams","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio14-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F12.fio14-c",{"title":4168,"path":4169,"stem":4170},"FIO15-C. Ensure that file operations are performed in a secure directory","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio15-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F13.fio15-c",{"title":4172,"path":4173,"stem":4174},"FIO17-C. Do not rely on an ending null character when using fread()","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio17-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F14.fio17-c",{"title":4176,"path":4177,"stem":4178},"FIO18-C. Never expect fwrite() to terminate the writing process at a null character","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio18-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F15.fio18-c",{"title":4180,"path":4181,"stem":4182},"FIO19-C. Do not use fseek() and ftell() to compute the size of a regular file","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio19-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F16.fio19-c",{"title":4184,"path":4185,"stem":4186},"FIO20-C. Avoid unintentional truncation when using fgets() or fgetws()","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio20-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F17.fio20-c",{"title":4188,"path":4189,"stem":4190},"FIO21-C. Do not create temporary files in shared directories","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio21-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F18.fio21-c",{"title":4192,"path":4193,"stem":4194},"FIO22-C. Close files before spawning processes","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio22-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F19.fio22-c",{"title":4196,"path":4197,"stem":4198},"FIO23-C. Do not exit with unflushed data in stdout or stderr","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio23-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F20.fio23-c",{"title":4200,"path":4201,"stem":4202},"FIO24-C. Do not open a file that is already open","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio\u002Ffio24-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F21.fio24-c",{"title":3194,"path":4204,"stem":4205,"children":4206},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F01.index",[4207,4208,4212,4216,4220,4224,4228,4232,4236,4240,4244,4248,4252,4256,4260,4264],{"title":3194,"path":4204,"stem":4205},{"title":4209,"path":4210,"stem":4211},"INT00-C. Understand the data model used by your implementation(s)","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F02.int00-c",{"title":4213,"path":4214,"stem":4215},"INT01-C. Use size_t or rsize_t for all integer values representing the size of an object","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F03.int01-c",{"title":4217,"path":4218,"stem":4219},"INT04-C. Enforce limits on integer values originating from tainted sources","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F05.int04-c",{"title":4221,"path":4222,"stem":4223},"INT05-C. Do not use input functions to convert character data if they cannot handle all possible inputs","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F06.int05-c",{"title":4225,"path":4226,"stem":4227},"INT07-C. Use only explicitly signed or unsigned char type for numeric values","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F07.int07-c",{"title":4229,"path":4230,"stem":4231},"INT08-C. Verify that all integer values are in range","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint08-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F08.int08-c",{"title":4233,"path":4234,"stem":4235},"INT09-C. Ensure enumeration constants map to unique values","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint09-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F09.int09-c",{"title":4237,"path":4238,"stem":4239},"INT10-C. Do not assume a positive remainder when using the % operator","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F10.int10-c",{"title":4241,"path":4242,"stem":4243},"INT12-C. Do not make assumptions about the type of a plain int bit-field when used in an expression","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint12-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F11.int12-c",{"title":4245,"path":4246,"stem":4247},"INT13-C. Use bitwise operators only on unsigned operands","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint13-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F12.int13-c",{"title":4249,"path":4250,"stem":4251},"INT14-C. Avoid performing bitwise and arithmetic operations on the same data","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint14-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F13.int14-c",{"title":4253,"path":4254,"stem":4255},"INT15-C. Use intmax_t or uintmax_t for formatted IO on programmer-defined integer types","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint15-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F14.int15-c",{"title":4257,"path":4258,"stem":4259},"INT16-C. Do not make assumptions about representation of signed integers","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint16-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F15.int16-c",{"title":4261,"path":4262,"stem":4263},"INT17-C. Define integer constants in an implementation-independent manner","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint17-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F16.int17-c",{"title":4265,"path":4266,"stem":4267},"INT18-C. Evaluate integer expressions in a larger size before comparing or assigning to that size","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int\u002Fint18-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F17.int18-c",{"title":3228,"path":4269,"stem":4270,"children":4271},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F01.index",[4272,4273,4277,4281,4285,4289,4293,4297,4301,4305,4309,4313],{"title":3228,"path":4269,"stem":4270},{"title":4274,"path":4275,"stem":4276},"MEM00-C. Allocate and free memory in the same module, at the same level of abstraction","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F02.mem00-c",{"title":4278,"path":4279,"stem":4280},"MEM01-C. Store a new value in pointers immediately after free()","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F03.mem01-c",{"title":4282,"path":4283,"stem":4284},"MEM02-C. Immediately cast the result of a memory allocation function call into a pointer to the allocated type","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F04.mem02-c",{"title":4286,"path":4287,"stem":4288},"MEM03-C. Clear sensitive information stored in reusable resources","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F05.mem03-c",{"title":4290,"path":4291,"stem":4292},"MEM04-C. Beware of zero-length allocations","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F06.mem04-c",{"title":4294,"path":4295,"stem":4296},"MEM05-C. Avoid large stack allocations","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F07.mem05-c",{"title":4298,"path":4299,"stem":4300},"MEM06-C. Ensure that sensitive data is not written out to disk","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F08.mem06-c",{"title":4302,"path":4303,"stem":4304},"MEM07-C. Ensure that the arguments to calloc(), when multiplied, do not wrap","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F09.mem07-c",{"title":4306,"path":4307,"stem":4308},"MEM10-C. Define and use a pointer validation function","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F10.mem10-c",{"title":4310,"path":4311,"stem":4312},"MEM11-C. Do not assume infinite heap space","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem11-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F11.mem11-c",{"title":4314,"path":4315,"stem":4316},"MEM12-C. Consider using a goto chain when leaving a function on error when using and releasing resources","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem\u002Fmem12-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F12.mem12-c",{"title":3258,"path":4318,"stem":4319,"children":4320},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F1.index",[4321,4322,4326,4330,4334,4338],{"title":3258,"path":4318,"stem":4319},{"title":4323,"path":4324,"stem":4325},"WIN00-C. Be specific when dynamically loading libraries","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win\u002Fwin00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F2.win00-c",{"title":4327,"path":4328,"stem":4329},"WIN01-C. Do not forcibly terminate execution","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win\u002Fwin01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F3.win01-c",{"title":4331,"path":4332,"stem":4333},"WIN02-C. Restrict privileges when spawning child processes","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win\u002Fwin02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F4.win02-c",{"title":4335,"path":4336,"stem":4337},"WIN03-C. Understand HANDLE inheritance","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win\u002Fwin03-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F5.win03-c",{"title":4339,"path":4340,"stem":4341},"WIN04-C. Consider encrypting function pointers","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win\u002Fwin04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F6.win04-c",{"title":3268,"path":4343,"stem":4344,"children":4345},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F01.index",[4346,4347,4351,4355,4359,4363,4367,4371,4375,4379,4383,4387,4391,4395,4399,4403,4407,4411,4415,4419,4423,4427,4431],{"title":3268,"path":4343,"stem":4344},{"title":4348,"path":4349,"stem":4350},"MSC00-C. Compile cleanly at high warning levels","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F02.msc00-c",{"title":4352,"path":4353,"stem":4354},"MSC01-C. Strive for logical completeness","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F03.msc01-c",{"title":4356,"path":4357,"stem":4358},"MSC04-C. Use comments consistently and in a readable fashion","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F04.msc04-c",{"title":4360,"path":4361,"stem":4362},"MSC05-C. Do not manipulate time_t typed values directly","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F05.msc05-c",{"title":4364,"path":4365,"stem":4366},"MSC06-C. Beware of compiler optimizations","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F06.msc06-c",{"title":4368,"path":4369,"stem":4370},"MSC07-C. Detect and remove dead code","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F07.msc07-c",{"title":4372,"path":4373,"stem":4374},"UTF8-related issues","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Futf8-related-issues","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F08.utf8-related-issues",{"title":4376,"path":4377,"stem":4378},"MSC11-C. Incorporate diagnostic tests using assertions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc11-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F09.msc11-c",{"title":4380,"path":4381,"stem":4382},"MSC12-C. Detect and remove code that has no effect or is never executed","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc12-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F10.msc12-c",{"title":4384,"path":4385,"stem":4386},"MSC13-C. Detect and remove unused values","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc13-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F11.msc13-c",{"title":4388,"path":4389,"stem":4390},"MSC14-C. Do not introduce unnecessary platform dependencies","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc14-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F12.msc14-c",{"title":4392,"path":4393,"stem":4394},"MSC15-C. Do not depend on undefined behavior","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc15-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F13.msc15-c",{"title":4396,"path":4397,"stem":4398},"MSC17-C. Finish every set of statements associated with a case label with a break statement","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc17-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F14.msc17-c",{"title":4400,"path":4401,"stem":4402},"MSC18-C. Be careful while handling sensitive data, such as passwords, in program code","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc18-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F15.msc18-c",{"title":4404,"path":4405,"stem":4406},"MSC19-C. For functions that return an array, prefer returning an empty array over a null value","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc19-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F16.msc19-c",{"title":4408,"path":4409,"stem":4410},"MSC20-C. Do not use a switch statement to transfer control into a complex block","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc20-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F17.msc20-c",{"title":4412,"path":4413,"stem":4414},"MSC21-C. Use robust loop termination conditions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc21-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F18.msc21-c",{"title":4416,"path":4417,"stem":4418},"MSC22-C. Use the setjmp(), longjmp() facility securely","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc22-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F19.msc22-c",{"title":4420,"path":4421,"stem":4422},"MSC23-C. Beware of vendor-specific library and language differences","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc23-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F20.msc23-c",{"title":4424,"path":4425,"stem":4426},"MSC24-C. Do not use deprecated or obsolescent functions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc24-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F21.msc24-c",{"title":4428,"path":4429,"stem":4430},"MSC25-C. Do not use insecure or weak cryptographic algorithms","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc25-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F22.msc25-c",{"title":4432,"path":4433,"stem":4434},"Use subset of ASCII for safety","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc\u002Fuse-subset-of-ascii-for-safety","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F23.use-subset-of-ascii-for-safety",{"title":3306,"path":4436,"stem":4437,"children":4438},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F1.index",[4439,4440,4444,4448,4452],{"title":3306,"path":4436,"stem":4437},{"title":4441,"path":4442,"stem":4443},"POS01-C. Check for the existence of links when dealing with files","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos\u002Fpos01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F2.pos01-c",{"title":4445,"path":4446,"stem":4447},"POS02-C. Follow the principle of least privilege","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos\u002Fpos02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F3.pos02-c",{"title":4449,"path":4450,"stem":4451},"POS04-C. Avoid using PTHREAD_MUTEX_NORMAL type mutex locks","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos\u002Fpos04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F4.pos04-c",{"title":4453,"path":4454,"stem":4455},"POS05-C. Limit access to files by creating a jail","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos\u002Fpos05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F5.pos05-c",{"title":3376,"path":4457,"stem":4458,"children":4459},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F01.index",[4460,4461,4465,4469,4473,4477,4481,4485,4489,4493,4497,4501,4505,4509],{"title":3376,"path":4457,"stem":4458},{"title":4462,"path":4463,"stem":4464},"PRE00-C. Prefer inline or static functions to function-like macros","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F02.pre00-c",{"title":4466,"path":4467,"stem":4468},"PRE01-C. Use parentheses within macros around parameter names","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F03.pre01-c",{"title":4470,"path":4471,"stem":4472},"PRE02-C. Macro replacement lists should be parenthesized","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F04.pre02-c",{"title":4474,"path":4475,"stem":4476},"PRE04-C. Do not reuse a standard header file name","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre04-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F05.pre04-c",{"title":4478,"path":4479,"stem":4480},"PRE05-C. Understand macro replacement when concatenating tokens or performing stringification","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre05-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F06.pre05-c",{"title":4482,"path":4483,"stem":4484},"PRE06-C. Enclose header files in an include guard","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre06-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F07.pre06-c",{"title":4486,"path":4487,"stem":4488},"PRE07-C. Avoid using repeated question marks","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre07-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F08.pre07-c",{"title":4490,"path":4491,"stem":4492},"PRE08-C. Guarantee that header file names are unique","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre08-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F09.pre08-c",{"title":4494,"path":4495,"stem":4496},"PRE09-C. Do not replace secure functions with deprecated or obsolescent functions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre09-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F10.pre09-c",{"title":4498,"path":4499,"stem":4500},"PRE10-C. Wrap multistatement macros in a do-while loop","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre10-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F11.pre10-c",{"title":4502,"path":4503,"stem":4504},"PRE11-C. Do not conclude macro definitions with a semicolon","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre11-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F12.pre11-c",{"title":4506,"path":4507,"stem":4508},"PRE12-C. Do not define unsafe macros","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre12-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F13.pre12-c",{"title":4510,"path":4511,"stem":4512},"PRE13-C. Use the Standard predefined macros to test for versions and features.","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre\u002Fpre13-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F14.pre13-c",{"title":3394,"path":4514,"stem":4515,"children":4516},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fsignals-sig","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F18.signals-sig\u002F1.index",[4517,4518,4522,4526],{"title":3394,"path":4514,"stem":4515},{"title":4519,"path":4520,"stem":4521},"SIG00-C. Mask signals handled by noninterruptible signal handlers","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fsignals-sig\u002Fsig00-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F18.signals-sig\u002F2.sig00-c",{"title":4523,"path":4524,"stem":4525},"SIG01-C. Understand implementation-specific details regarding signal handler persistence","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fsignals-sig\u002Fsig01-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F18.signals-sig\u002F3.sig01-c",{"title":4527,"path":4528,"stem":4529},"SIG02-C. Avoid using signals to implement normal functionality","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fsignals-sig\u002Fsig02-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F18.signals-sig\u002F4.sig02-c",{"title":4531,"path":4532,"stem":4533},"CERT manifest files","\u002Fsei-cert-c-coding-standard\u002Fcert-manifest-files","4.sei-cert-c-coding-standard\u002F09.cert-manifest-files",1775657798722]