[{"data":1,"prerenderedAt":3884},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio34-c":28,"surround-\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio34-c":2108,"sidebar-sei-cert-c-coding-standard":2115},[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":2094,"extension":2095,"meta":2096,"navigation":7,"path":2104,"seo":2105,"stem":2106,"__hash__":2107},"content\u002F4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F04.fio34-c.md","FIO34-C. Distinguish between characters read from a file and EOF or WEOF",{"type":32,"value":33,"toc":2076},"minimark",[34,38,61,94,125,157,187,203,226,231,241,354,369,373,387,488,492,518,627,655,659,668,765,769,780,1006,1026,1029,1044,1274,1278,1319,1323,1339,1405,1410,1845,1849,1862,1866,1873,1974,1978,1984,1988,1991,1994,1998,2047,2050,2072],[35,36,30],"h1",{"id":37},"fio34-c-distinguish-between-characters-read-from-a-file-and-eof-or-weof",[39,40,41,42,46,47,49,50,55,56,60],"p",{},"The ",[43,44,45],"code",{},"EOF"," macro represents a negative value that is used to indicate that the file is exhausted and no data remains when reading data from a file. ",[43,48,45],{}," is an example of an ",[51,52,54],"a",{"href":53},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-in-banderrorindicator","in-band error indicator"," . In-band error indicators are problematic to work with, and the creation of new in-band-error indicators is discouraged by ",[51,57,59],{"href":58},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err\u002Ferr02-c","ERR02-C. Avoid in-band error indicators"," .",[39,62,63,64,67,68,71,72,75,76,79,80,84,85,87,88,90,91,60],{},"The byte I\u002FO functions ",[43,65,66],{},"fgetc()"," , ",[43,69,70],{},"getc()"," , and ",[43,73,74],{},"getchar()"," all read a character from a stream and return it as an ",[43,77,78],{},"int."," (See ",[51,81,83],{"href":82},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr00-c","STR00-C. Represent characters using an appropriate type"," .) If the stream is at the end of the file, the end-of-file indicator for the stream is set and the function returns ",[43,86,45],{}," . If a read error occurs, the error indicator for the stream is set and the function returns ",[43,89,45],{}," . If these functions succeed, they cast the character returned into an ",[43,92,93],{},"  unsigned char ",[39,95,96,97,99,100,104,105,108,109,112,113,115,116,118,119,121,122,124],{},"Because ",[43,98,45],{}," is negative, it should not match any unsigned character value. However, this is only true for ",[51,101,103],{"href":102},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-implementation","implementations"," where the ",[43,106,107],{},"int"," type is wider than ",[43,110,111],{},"char"," . On an implementation where ",[43,114,107],{}," and ",[43,117,111],{}," have the same width, a character-reading function can read and return a valid character that has the same bit-pattern as ",[43,120,45],{}," . This could occur, for example, if an attacker inserted a value that looked like ",[43,123,45],{}," into the file or data stream to alter the behavior of the program.",[39,126,127,128,130,131,133,134,136,137,139,140,143,144,115,147,150,151,153,154,60],{},"The C Standard requires only that the ",[43,129,107],{}," type be able to represent a maximum value of +32767 and that a ",[43,132,111],{}," type be no larger than an ",[43,135,107],{}," . Although uncommon, this situation can result in the integer constant expression ",[43,138,45],{}," being indistinguishable from a valid character; that is, ",[43,141,142],{},"  (int)(unsigned char)65535 == -1 "," . Consequently, failing to use ",[43,145,146],{},"feof()",[43,148,149],{},"ferror()"," to detect end-of-file and file errors can result in incorrectly identifying the ",[43,152,45],{}," character on rare implementations where ",[43,155,156],{},"  sizeof(int) == sizeof(char) ",[39,158,159,160,67,163,71,166,169,170,173,174,177,178,181,182,184,185,60],{},"This problem is much more common when reading wide characters. The ",[43,161,162],{},"fgetwc()",[43,164,165],{},"getwc()",[43,167,168],{},"getwchar()"," functions return a value of type ",[43,171,172],{},"wint_t"," . This value can represent the next wide character read, or it can represent ",[43,175,176],{},"WEOF"," , which indicates end-of-file for wide character streams. On most implementations, the ",[43,179,180],{},"wchar_t"," type has the same width as ",[43,183,172],{}," , and these functions can return a character indistinguishable from ",[43,186,176],{},[39,188,189,190,193,194,196,197,200,201,60],{},"In the UTF-16 character set, ",[43,191,192],{},"0xFFFF"," is guaranteed not to be a character, which allows ",[43,195,176],{}," to be represented as the value ",[43,198,199],{},"-1"," . Similarly, all UTF-32 characters are positive when viewed as a signed 32-bit integer. All widely used character sets are designed with at least one value that does not represent a character. Consequently, it would require a custom character set designed without consideration of the C programming language for this problem to occur with wide characters or with ordinary characters that are as wide as ",[43,202,107],{},[39,204,205,206,115,208,210,211,215,216,115,218,220,221,115,223,225],{},"The C Standard ",[43,207,146],{},[43,209,149],{}," functions are not subject to the problems associated with character and integer sizes and should be used to verify end-of-file and file errors for susceptible implementations [ ",[51,212,214],{"href":213},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-Kettle02","Kettlewell 2002"," ]. Calling both functions on each iteration of a loop adds significant overhead, so a good strategy is to temporarily trust ",[43,217,45],{},[43,219,176],{}," within the loop but verify them with ",[43,222,146],{},[43,224,149],{}," following the loop.",[227,228,230],"h2",{"id":229},"noncompliant-code-example","Noncompliant Code Example",[39,232,233,234,237,238,240],{},"This noncompliant code example loops while the character ",[43,235,236],{},"c"," is not ",[43,239,45],{}," :",[242,243,245],"code-block",{"quality":244},"bad",[246,247,251],"pre",{"className":248,"code":249,"language":236,"meta":250,"style":250},"language-c shiki shiki-themes github-light github-dark monokai","#include \u003Cstdio.h>\n \nvoid func(void) {\n  int c;\n \n  do {\n    c = getchar();\n  } while (c != EOF);\n}\n","",[43,252,253,266,273,292,301,306,315,330,348],{"__ignoreMap":250},[254,255,258,262],"span",{"class":256,"line":257},"line",1,[254,259,261],{"class":260},"sC2Qs","#include",[254,263,265],{"class":264},"sstjo"," \u003Cstdio.h>\n",[254,267,269],{"class":256,"line":268},2,[254,270,272],{"class":271},"sMOD_"," \n",[254,274,276,280,284,287,289],{"class":256,"line":275},3,[254,277,279],{"class":278},"sq6CD","void",[254,281,283],{"class":282},"srTi1"," func",[254,285,286],{"class":271},"(",[254,288,279],{"class":278},[254,290,291],{"class":271},") {\n",[254,293,295,298],{"class":256,"line":294},4,[254,296,297],{"class":278},"  int",[254,299,300],{"class":271}," c;\n",[254,302,304],{"class":256,"line":303},5,[254,305,272],{"class":271},[254,307,309,312],{"class":256,"line":308},6,[254,310,311],{"class":260},"  do",[254,313,314],{"class":271}," {\n",[254,316,318,321,324,327],{"class":256,"line":317},7,[254,319,320],{"class":271},"    c ",[254,322,323],{"class":260},"=",[254,325,326],{"class":282}," getchar",[254,328,329],{"class":271},"();\n",[254,331,333,336,339,342,345],{"class":256,"line":332},8,[254,334,335],{"class":271},"  } ",[254,337,338],{"class":260},"while",[254,340,341],{"class":271}," (c ",[254,343,344],{"class":260},"!=",[254,346,347],{"class":271}," EOF);\n",[254,349,351],{"class":256,"line":350},9,[254,352,353],{"class":271},"}\n",[39,355,356,357,359,360,362,363,365,366,368],{},"Although ",[43,358,45],{}," is guaranteed to be negative and distinct from the value of any unsigned character, it is not guaranteed to be different from any such value when converted to an ",[43,361,107],{}," . Consequently, when ",[43,364,107],{}," has the same width as ",[43,367,111],{}," , this loop may terminate prematurely.",[227,370,372],{"id":371},"compliant-solution-portable","Compliant Solution (Portable)",[39,374,375,376,115,378,380,381,383,384,386],{},"This compliant solution uses ",[43,377,146],{},[43,379,149],{}," to test whether the ",[43,382,45],{}," was an actual character or a real ",[43,385,45],{}," because of end-of-file or errors:",[242,388,390],{"quality":389},"good",[246,391,393],{"className":248,"code":392,"language":236,"meta":250,"style":250},"#include \u003Cstdio.h>\n\nvoid func(void) {\n  int c;\n\n  do {\n    c = getchar();\n  } while (c != EOF || (!feof(stdin) && !ferror(stdin)));\n}\n",[43,394,395,401,406,418,424,428,434,444,484],{"__ignoreMap":250},[254,396,397,399],{"class":256,"line":257},[254,398,261],{"class":260},[254,400,265],{"class":264},[254,402,403],{"class":256,"line":268},[254,404,405],{"emptyLinePlaceholder":7},"\n",[254,407,408,410,412,414,416],{"class":256,"line":275},[254,409,279],{"class":278},[254,411,283],{"class":282},[254,413,286],{"class":271},[254,415,279],{"class":278},[254,417,291],{"class":271},[254,419,420,422],{"class":256,"line":294},[254,421,297],{"class":278},[254,423,300],{"class":271},[254,425,426],{"class":256,"line":303},[254,427,405],{"emptyLinePlaceholder":7},[254,429,430,432],{"class":256,"line":308},[254,431,311],{"class":260},[254,433,314],{"class":271},[254,435,436,438,440,442],{"class":256,"line":317},[254,437,320],{"class":271},[254,439,323],{"class":260},[254,441,326],{"class":282},[254,443,329],{"class":271},[254,445,446,448,450,452,454,457,460,463,466,469,472,475,478,481],{"class":256,"line":332},[254,447,335],{"class":271},[254,449,338],{"class":260},[254,451,341],{"class":271},[254,453,344],{"class":260},[254,455,456],{"class":271}," EOF ",[254,458,459],{"class":260},"||",[254,461,462],{"class":271}," (",[254,464,465],{"class":260},"!",[254,467,468],{"class":282},"feof",[254,470,471],{"class":271},"(stdin) ",[254,473,474],{"class":260},"&&",[254,476,477],{"class":260}," !",[254,479,480],{"class":282},"ferror",[254,482,483],{"class":271},"(stdin)));\n",[254,485,486],{"class":256,"line":350},[254,487,353],{"class":271},[227,489,491],{"id":490},"noncompliant-code-example-nonportable","Noncompliant Code Example (Nonportable)",[39,493,494,495,497,498,115,500,502,503,505,506,508,509,511,512,514,515,517],{},"This noncompliant code example uses an assertion to ensure that the code is executed only on architectures where ",[43,496,107],{}," is wider than ",[43,499,111],{},[43,501,45],{}," is guaranteed not to be a valid character value. However, this code example is noncompliant because the variable ",[43,504,236],{}," is declared as a ",[43,507,111],{}," rather than an ",[43,510,107],{}," , making it possible for a valid character value to compare equal to the value of the ",[43,513,45],{}," macro when ",[43,516,111],{}," is signed because of sign extension:",[242,519,520],{"quality":244},[246,521,523],{"className":248,"code":522,"language":236,"meta":250,"style":250},"#include \u003Cassert.h>\n#include \u003Climits.h>\n#include \u003Cstdio.h>\n\nvoid func(void) {\n  char c;\n  static_assert(UCHAR_MAX \u003C UINT_MAX, \"FIO34-C violation\");\n\n  do {\n    c = getchar();\n  } while (c != EOF);\n}\n",[43,524,525,532,539,545,549,561,568,588,592,598,609,622],{"__ignoreMap":250},[254,526,527,529],{"class":256,"line":257},[254,528,261],{"class":260},[254,530,531],{"class":264}," \u003Cassert.h>\n",[254,533,534,536],{"class":256,"line":268},[254,535,261],{"class":260},[254,537,538],{"class":264}," \u003Climits.h>\n",[254,540,541,543],{"class":256,"line":275},[254,542,261],{"class":260},[254,544,265],{"class":264},[254,546,547],{"class":256,"line":294},[254,548,405],{"emptyLinePlaceholder":7},[254,550,551,553,555,557,559],{"class":256,"line":303},[254,552,279],{"class":278},[254,554,283],{"class":282},[254,556,286],{"class":271},[254,558,279],{"class":278},[254,560,291],{"class":271},[254,562,563,566],{"class":256,"line":308},[254,564,565],{"class":278},"  char",[254,567,300],{"class":271},[254,569,570,573,576,579,582,585],{"class":256,"line":317},[254,571,572],{"class":282},"  static_assert",[254,574,575],{"class":271},"(UCHAR_MAX ",[254,577,578],{"class":260},"\u003C",[254,580,581],{"class":271}," UINT_MAX, ",[254,583,584],{"class":264},"\"FIO34-C violation\"",[254,586,587],{"class":271},");\n",[254,589,590],{"class":256,"line":332},[254,591,405],{"emptyLinePlaceholder":7},[254,593,594,596],{"class":256,"line":350},[254,595,311],{"class":260},[254,597,314],{"class":271},[254,599,601,603,605,607],{"class":256,"line":600},10,[254,602,320],{"class":271},[254,604,323],{"class":260},[254,606,326],{"class":282},[254,608,329],{"class":271},[254,610,612,614,616,618,620],{"class":256,"line":611},11,[254,613,335],{"class":271},[254,615,338],{"class":260},[254,617,341],{"class":271},[254,619,344],{"class":260},[254,621,347],{"class":271},[254,623,625],{"class":256,"line":624},12,[254,626,353],{"class":271},[39,628,629,630,632,633,635,636,639,640,642,643,646,647,649,650,654],{},"Assuming that a ",[43,631,111],{}," is a signed 8-bit type and an int is a 32-bit type, if ",[43,634,74],{}," returns the character value ",[43,637,638],{},"'\\xff"," (decimal 255), it will be interpreted as ",[43,641,45],{}," because this value is sign-extended to ",[43,644,645],{},"0xFFFFFFFF"," (the value of ",[43,648,45],{}," ) to perform the comparison. (See ",[51,651,653],{"href":652},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr34-c","STR34-C. Cast characters to unsigned char before converting to larger integer sizes"," .)",[227,656,658],{"id":657},"compliant-solution-nonportable","Compliant Solution (Nonportable)",[39,660,661,662,664,665,667],{},"This compliant solution declares ",[43,663,236],{}," to be an ",[43,666,107],{}," . Consequently, the loop will terminate only when the file is exhausted.",[242,669,670],{"quality":389},[246,671,673],{"className":248,"code":672,"language":236,"meta":250,"style":250},"#include \u003Cassert.h>\n#include \u003Cstdio.h>\n#include \u003Climits.h>\n\nvoid func(void) {\n  int c;\n  static_assert(UCHAR_MAX \u003C UINT_MAX, \"FIO34-C violation\");\n\n  do {\n    c = getchar();\n  } while (c != EOF);\n}\n",[43,674,675,681,687,693,697,709,715,729,733,739,749,761],{"__ignoreMap":250},[254,676,677,679],{"class":256,"line":257},[254,678,261],{"class":260},[254,680,531],{"class":264},[254,682,683,685],{"class":256,"line":268},[254,684,261],{"class":260},[254,686,265],{"class":264},[254,688,689,691],{"class":256,"line":275},[254,690,261],{"class":260},[254,692,538],{"class":264},[254,694,695],{"class":256,"line":294},[254,696,405],{"emptyLinePlaceholder":7},[254,698,699,701,703,705,707],{"class":256,"line":303},[254,700,279],{"class":278},[254,702,283],{"class":282},[254,704,286],{"class":271},[254,706,279],{"class":278},[254,708,291],{"class":271},[254,710,711,713],{"class":256,"line":308},[254,712,297],{"class":278},[254,714,300],{"class":271},[254,716,717,719,721,723,725,727],{"class":256,"line":317},[254,718,572],{"class":282},[254,720,575],{"class":271},[254,722,578],{"class":260},[254,724,581],{"class":271},[254,726,584],{"class":264},[254,728,587],{"class":271},[254,730,731],{"class":256,"line":332},[254,732,405],{"emptyLinePlaceholder":7},[254,734,735,737],{"class":256,"line":350},[254,736,311],{"class":260},[254,738,314],{"class":271},[254,740,741,743,745,747],{"class":256,"line":600},[254,742,320],{"class":271},[254,744,323],{"class":260},[254,746,326],{"class":282},[254,748,329],{"class":271},[254,750,751,753,755,757,759],{"class":256,"line":611},[254,752,335],{"class":271},[254,754,338],{"class":260},[254,756,341],{"class":271},[254,758,344],{"class":260},[254,760,347],{"class":271},[254,762,763],{"class":256,"line":624},[254,764,353],{"class":271},[227,766,768],{"id":767},"noncompliant-code-example-wide-characters","Noncompliant Code Example (Wide Characters)",[39,770,771,772,774,775,777,778,240],{},"In this noncompliant example, the result of the call to the C standard library function ",[43,773,165],{}," is stored into a variable of type ",[43,776,180],{}," and is subsequently compared with ",[43,779,176],{},[242,781,782],{"quality":244},[246,783,785],{"className":248,"code":784,"language":236,"meta":250,"style":250},"#include \u003Cstddef.h>\n#include \u003Cstdio.h>\n#include \u003Cwchar.h>\n\nenum { BUFFER_SIZE = 32 };\n\nvoid g(void) {\n  wchar_t buf[BUFFER_SIZE];\n  wchar_t wc;\n  size_t i = 0;\n\n  while ((wc = getwc(stdin)) != L'\\n' && wc != WEOF) {\n    if (i \u003C (BUFFER_SIZE - 1)) {\n      buf[i++] = wc;\n    }\n  }\n  buf[i] = L'\\0';\n}\n",[43,786,787,794,800,807,811,828,832,845,858,865,881,885,925,948,967,973,979,1001],{"__ignoreMap":250},[254,788,789,791],{"class":256,"line":257},[254,790,261],{"class":260},[254,792,793],{"class":264}," \u003Cstddef.h>\n",[254,795,796,798],{"class":256,"line":268},[254,797,261],{"class":260},[254,799,265],{"class":264},[254,801,802,804],{"class":256,"line":275},[254,803,261],{"class":260},[254,805,806],{"class":264}," \u003Cwchar.h>\n",[254,808,809],{"class":256,"line":294},[254,810,405],{"emptyLinePlaceholder":7},[254,812,813,816,819,821,825],{"class":256,"line":303},[254,814,815],{"class":278},"enum",[254,817,818],{"class":271}," { BUFFER_SIZE ",[254,820,323],{"class":260},[254,822,824],{"class":823},"s7F3e"," 32",[254,826,827],{"class":271}," };\n",[254,829,830],{"class":256,"line":308},[254,831,405],{"emptyLinePlaceholder":7},[254,833,834,836,839,841,843],{"class":256,"line":317},[254,835,279],{"class":278},[254,837,838],{"class":282}," g",[254,840,286],{"class":271},[254,842,279],{"class":278},[254,844,291],{"class":271},[254,846,847,851,855],{"class":256,"line":332},[254,848,850],{"class":849},"s-m8C","  wchar_t",[254,852,854],{"class":853},"sOrwc"," buf",[254,856,857],{"class":271},"[BUFFER_SIZE];\n",[254,859,860,862],{"class":256,"line":350},[254,861,850],{"class":849},[254,863,864],{"class":271}," wc;\n",[254,866,867,870,873,875,878],{"class":256,"line":600},[254,868,869],{"class":278},"  size_t",[254,871,872],{"class":271}," i ",[254,874,323],{"class":260},[254,876,877],{"class":823}," 0",[254,879,880],{"class":271},";\n",[254,882,883],{"class":256,"line":611},[254,884,405],{"emptyLinePlaceholder":7},[254,886,887,890,893,895,898,901,903,906,909,912,914,917,920,922],{"class":256,"line":624},[254,888,889],{"class":260},"  while",[254,891,892],{"class":271}," ((wc ",[254,894,323],{"class":260},[254,896,897],{"class":282}," getwc",[254,899,900],{"class":271},"(stdin)) ",[254,902,344],{"class":260},[254,904,905],{"class":271}," L",[254,907,908],{"class":264},"'",[254,910,911],{"class":823},"\\n",[254,913,908],{"class":264},[254,915,916],{"class":260}," &&",[254,918,919],{"class":271}," wc ",[254,921,344],{"class":260},[254,923,924],{"class":271}," WEOF) {\n",[254,926,928,931,934,936,939,942,945],{"class":256,"line":927},13,[254,929,930],{"class":260},"    if",[254,932,933],{"class":271}," (i ",[254,935,578],{"class":260},[254,937,938],{"class":271}," (BUFFER_SIZE ",[254,940,941],{"class":260},"-",[254,943,944],{"class":823}," 1",[254,946,947],{"class":271},")) {\n",[254,949,951,954,957,960,963,965],{"class":256,"line":950},14,[254,952,953],{"class":853},"      buf",[254,955,956],{"class":271},"[i",[254,958,959],{"class":260},"++",[254,961,962],{"class":271},"] ",[254,964,323],{"class":260},[254,966,864],{"class":271},[254,968,970],{"class":256,"line":969},15,[254,971,972],{"class":271},"    }\n",[254,974,976],{"class":256,"line":975},16,[254,977,978],{"class":271},"  }\n",[254,980,982,985,988,990,992,994,997,999],{"class":256,"line":981},17,[254,983,984],{"class":853},"  buf",[254,986,987],{"class":271},"[i] ",[254,989,323],{"class":260},[254,991,905],{"class":271},[254,993,908],{"class":264},[254,995,996],{"class":823},"\\0",[254,998,908],{"class":264},[254,1000,880],{"class":271},[254,1002,1004],{"class":256,"line":1003},18,[254,1005,353],{"class":271},[39,1007,1008,1009,1011,1012,1014,1015,1017,1018,497,1020,1022,1023,1025],{},"This code suffers from two problems. First, the value returned by ",[43,1010,165],{}," is immediately converted to ",[43,1013,180],{}," before being compared with ",[43,1016,176],{}," . Second, there is no check to ensure that ",[43,1019,172],{},[43,1021,180],{}," . Both of these problems make it possible for an attacker to terminate the loop prematurely by supplying the wide-character value matching ",[43,1024,176],{}," in the file.",[227,1027,372],{"id":1028},"compliant-solution-portable-1",[39,1030,661,1031,1034,1035,1037,1038,1040,1041,1043],{},[43,1032,1033],{},"wc"," to be a ",[43,1036,172],{}," to match the integer type returned by ",[43,1039,165],{}," . Furthermore, it does not rely on ",[43,1042,176],{}," to determine end-of-file definitively.",[242,1045,1046],{"quality":389},[246,1047,1049],{"className":248,"code":1048,"language":236,"meta":250,"style":250},"#include \u003Cstddef.h>\n#include \u003Cstdio.h>\n#include \u003Cwchar.h>\n \nenum {BUFFER_SIZE = 32 }\n\nvoid g(void) {\n  wchar_t buf[BUFFER_SIZE];\n  wint_t wc;\n  size_t i = 0;\n  \n  while ((wc = getwc(stdin)) != L'\\n' && wc != WEOF) {\n    if (i \u003C BUFFER_SIZE - 1) {\n      buf[i++] = wc;\n    }\n  }\n\n  if (feof(stdin) || ferror(stdin)) {\n   buf[i] = L'\\0';\n  } else {\n    \u002F* Received a wide character that resembles WEOF; handle error *\u002F\n  }\n}\n",[43,1050,1051,1057,1063,1069,1073,1087,1091,1103,1111,1118,1130,1135,1165,1182,1196,1200,1204,1208,1227,1247,1257,1264,1269],{"__ignoreMap":250},[254,1052,1053,1055],{"class":256,"line":257},[254,1054,261],{"class":260},[254,1056,793],{"class":264},[254,1058,1059,1061],{"class":256,"line":268},[254,1060,261],{"class":260},[254,1062,265],{"class":264},[254,1064,1065,1067],{"class":256,"line":275},[254,1066,261],{"class":260},[254,1068,806],{"class":264},[254,1070,1071],{"class":256,"line":294},[254,1072,272],{"class":271},[254,1074,1075,1077,1080,1082,1084],{"class":256,"line":303},[254,1076,815],{"class":278},[254,1078,1079],{"class":271}," {BUFFER_SIZE ",[254,1081,323],{"class":260},[254,1083,824],{"class":823},[254,1085,1086],{"class":271}," }\n",[254,1088,1089],{"class":256,"line":308},[254,1090,405],{"emptyLinePlaceholder":7},[254,1092,1093,1095,1097,1099,1101],{"class":256,"line":317},[254,1094,279],{"class":278},[254,1096,838],{"class":282},[254,1098,286],{"class":271},[254,1100,279],{"class":278},[254,1102,291],{"class":271},[254,1104,1105,1107,1109],{"class":256,"line":332},[254,1106,850],{"class":849},[254,1108,854],{"class":853},[254,1110,857],{"class":271},[254,1112,1113,1116],{"class":256,"line":350},[254,1114,1115],{"class":849},"  wint_t",[254,1117,864],{"class":271},[254,1119,1120,1122,1124,1126,1128],{"class":256,"line":600},[254,1121,869],{"class":278},[254,1123,872],{"class":271},[254,1125,323],{"class":260},[254,1127,877],{"class":823},[254,1129,880],{"class":271},[254,1131,1132],{"class":256,"line":611},[254,1133,1134],{"class":271},"  \n",[254,1136,1137,1139,1141,1143,1145,1147,1149,1151,1153,1155,1157,1159,1161,1163],{"class":256,"line":624},[254,1138,889],{"class":260},[254,1140,892],{"class":271},[254,1142,323],{"class":260},[254,1144,897],{"class":282},[254,1146,900],{"class":271},[254,1148,344],{"class":260},[254,1150,905],{"class":271},[254,1152,908],{"class":264},[254,1154,911],{"class":823},[254,1156,908],{"class":264},[254,1158,916],{"class":260},[254,1160,919],{"class":271},[254,1162,344],{"class":260},[254,1164,924],{"class":271},[254,1166,1167,1169,1171,1173,1176,1178,1180],{"class":256,"line":927},[254,1168,930],{"class":260},[254,1170,933],{"class":271},[254,1172,578],{"class":260},[254,1174,1175],{"class":271}," BUFFER_SIZE ",[254,1177,941],{"class":260},[254,1179,944],{"class":823},[254,1181,291],{"class":271},[254,1183,1184,1186,1188,1190,1192,1194],{"class":256,"line":950},[254,1185,953],{"class":853},[254,1187,956],{"class":271},[254,1189,959],{"class":260},[254,1191,962],{"class":271},[254,1193,323],{"class":260},[254,1195,864],{"class":271},[254,1197,1198],{"class":256,"line":969},[254,1199,972],{"class":271},[254,1201,1202],{"class":256,"line":975},[254,1203,978],{"class":271},[254,1205,1206],{"class":256,"line":981},[254,1207,405],{"emptyLinePlaceholder":7},[254,1209,1210,1213,1215,1217,1219,1221,1224],{"class":256,"line":1003},[254,1211,1212],{"class":260},"  if",[254,1214,462],{"class":271},[254,1216,468],{"class":282},[254,1218,471],{"class":271},[254,1220,459],{"class":260},[254,1222,1223],{"class":282}," ferror",[254,1225,1226],{"class":271},"(stdin)) {\n",[254,1228,1230,1233,1235,1237,1239,1241,1243,1245],{"class":256,"line":1229},19,[254,1231,1232],{"class":853},"   buf",[254,1234,987],{"class":271},[254,1236,323],{"class":260},[254,1238,905],{"class":271},[254,1240,908],{"class":264},[254,1242,996],{"class":823},[254,1244,908],{"class":264},[254,1246,880],{"class":271},[254,1248,1250,1252,1255],{"class":256,"line":1249},20,[254,1251,335],{"class":271},[254,1253,1254],{"class":260},"else",[254,1256,314],{"class":271},[254,1258,1260],{"class":256,"line":1259},21,[254,1261,1263],{"class":1262},"s8-w5","    \u002F* Received a wide character that resembles WEOF; handle error *\u002F\n",[254,1265,1267],{"class":256,"line":1266},22,[254,1268,978],{"class":271},[254,1270,1272],{"class":256,"line":1271},23,[254,1273,353],{"class":271},[227,1275,1277],{"id":1276},"exceptions","Exceptions",[39,1279,1280,1284,1285,1287,1288,67,1291,67,1294,67,1297,67,1300,67,1303,67,1306,67,1309,71,1312,1315,1316,1318],{},[1281,1282,1283],"strong",{},"FIO34-C-EX1:"," A number of C functions do not return characters but can return ",[43,1286,45],{}," as a status code. These functions include ",[43,1289,1290],{},"fclose()",[43,1292,1293],{},"fflush()",[43,1295,1296],{},"fputs()",[43,1298,1299],{},"fscanf()",[43,1301,1302],{},"puts()",[43,1304,1305],{},"scanf()",[43,1307,1308],{},"sscanf()",[43,1310,1311],{},"vfscanf()",[43,1313,1314],{},"vscanf()"," . These return values can be compared to ",[43,1317,45],{}," without validating the result.",[227,1320,1322],{"id":1321},"risk-assessment","Risk Assessment",[39,1324,1325,1326,1328,1329,1331,1332,1338],{},"Incorrectly assuming characters from a file cannot match ",[43,1327,45],{}," or ",[43,1330,176],{}," has resulted in significant vulnerabilities, including command injection attacks. (See the ",[51,1333,1337],{"href":1334,"rel":1335},"http:\u002F\u002Fwww.cert.org\u002Fhistorical\u002Fadvisories\u002FCA-1996-22.cfm",[1336],"nofollow","*CA-1996-22"," advisory.)",[1340,1341,1342,1343,1342,1373],"table",{},"\n  ",[1344,1345,1346,1347,1342],"thead",{},"\n    ",[1348,1349,1350,1351,1350,1355,1350,1358,1350,1361,1350,1364,1350,1367,1350,1370,1346],"tr",{},"\n      ",[1352,1353,1354],"th",{},"Rule",[1352,1356,1357],{},"Severity",[1352,1359,1360],{},"Likelihood",[1352,1362,1363],{},"Detectable",[1352,1365,1366],{},"Repairable",[1352,1368,1369],{},"Priority",[1352,1371,1372],{},"Level",[1374,1375,1346,1376,1342],"tbody",{},[1348,1377,1350,1378,1350,1382,1350,1385,1350,1388,1350,1391,1350,1393,1350,1400,1346],{},[1379,1380,1381],"td",{},"FIO34-C",[1379,1383,1384],{},"High",[1379,1386,1387],{},"Probable",[1379,1389,1390],{},"Yes",[1379,1392,1390],{},[1379,1394,1396],{"style":1395},"color: #e74c3c;",[1397,1398,1399],"b",{},"P18",[1379,1401,1402],{"style":1395},[1397,1403,1404],{},"L1",[1406,1407,1409],"h3",{"id":1408},"automated-detection","Automated Detection",[1340,1411,1414],{"className":1412},[1413],"wrapped",[1374,1415,1416,1440,1468,1496,1519,1546,1592,1627,1653,1686,1709,1734,1760,1796,1820],{},[1348,1417,1420,1425,1430,1435],{"className":1418},[1419],"header",[1352,1421,1422],{},[39,1423,1424],{},"Tool",[1352,1426,1427],{},[39,1428,1429],{},"Version",[1352,1431,1432],{},[39,1433,1434],{},"Checker",[1352,1436,1437],{},[39,1438,1439],{},"Description",[1348,1441,1444,1450,1458,1465],{"className":1442},[1443],"odd",[1379,1445,1446],{},[51,1447,1449],{"href":1448},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fastree","Astrée",[1379,1451,1452],{},[1453,1454,1457],"div",{"className":1455},[1456],"content-wrapper","25.10",[1379,1459,1460],{},[39,1461,1462],{},[1281,1463,1464],{},"eof-small-int-comparison",[1379,1466,1467],{},"Partially checked + soundly supported",[1348,1469,1472,1478,1486,1491],{"className":1470},[1471],"even",[1379,1473,1474],{},[51,1475,1477],{"href":1476},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Faxivion-bauhaus-suite","Axivion Bauhaus Suite",[1379,1479,1480],{},[1453,1481,1483],{"className":1482},[1456],[39,1484,1485],{},"7.2.0",[1379,1487,1488],{},[1281,1489,1490],{},"CertC-FIO34",[1379,1492,1493],{},[1494,1495],"br",{},[1348,1497,1499,1505,1511,1516],{"className":1498},[1443],[1379,1500,1501],{},[51,1502,1504],{"href":1503},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcodesonar","CodeSonar",[1379,1506,1507],{},[1453,1508,1510],{"className":1509},[1456],"9.1p0",[1379,1512,1513],{},[1281,1514,1515],{},"LANG.CAST.COERCE",[1379,1517,1518],{},"Coercion alters value",[1348,1520,1522,1528,1534,1540],{"className":1521},[1471],[1379,1523,1524],{},[51,1525,1527],{"href":1526},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Frose","Compass\u002FROSE",[1379,1529,1530],{},[39,1531,1532],{},[1494,1533],{},[1379,1535,1536],{},[39,1537,1538],{},[1494,1539],{},[1379,1541,1542],{},[39,1543,1544],{},[1494,1545],{},[1348,1547,1549,1555,1561,1568],{"className":1548},[1443],[1379,1550,1551],{},[51,1552,1554],{"href":1553},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcoverity","Coverity",[1379,1556,1557],{},[1453,1558,1560],{"className":1559},[1456],"2017.07",[1379,1562,1563],{},[39,1564,1565],{},[1281,1566,1567],{},"CHAR_IO",[1379,1569,1570],{},[39,1571,1572,1573,67,1576,1579,1580,1583,1584,1587,1588,1591],{},"Identifies defects when the return value of ",[43,1574,1575],{},"       fgetc()      ",[43,1577,1578],{},"       getc()      "," , or ",[43,1581,1582],{},"       getchar()      "," is incorrectly assigned to a ",[43,1585,1586],{},"       char      "," instead of an ",[43,1589,1590],{},"       int      "," . Coverity Prevent cannot discover all violations of this rule, so further verification is necessary",[1348,1593,1595,1602,1614,1621],{"className":1594},[1471],[1379,1596,1598],{"style":1597},"text-align: left;",[51,1599,1601],{"href":1600},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fcppcheck-premium","Cppcheck Premium",[1379,1603,1604,1605,1607],{"style":1597},"24.11.0",[1494,1606],{},[1453,1608,1610],{"className":1609},[1456],[39,1611,1612],{},[1494,1613],{},[1379,1615,1616],{"style":1597},[39,1617,1618],{},[1281,1619,1620],{},"premium-cert-fio34-c",[1379,1622,1623],{"style":1597},[39,1624,1625],{},[1494,1626],{},[1348,1628,1630,1636,1639,1648],{"className":1629},[1443],[1379,1631,1632],{},[51,1633,1635],{"href":1634},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Feclair","ECLAIR",[1379,1637,1638],{},"1.2",[1379,1640,1641],{},[39,1642,1643],{},[1281,1644,1645,1646],{},"CC2.FIO34",[1494,1647],{},[1379,1649,1650],{},[39,1651,1652],{},"Partially implemented",[1348,1654,1656,1662,1670,1682],{"className":1655},[1471],[1379,1657,1658],{},[51,1659,1661],{"href":1660},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fhelix-qac","Helix QAC",[1379,1663,1664],{},[1453,1665,1667],{"className":1666},[1456],[39,1668,1669],{},"2025.2",[1379,1671,1672,1677],{},[39,1673,1674],{},[1281,1675,1676],{},"C2676, C2678",[39,1678,1679],{},[1281,1680,1681],{},"C++2676, C++2678, C++3001, C++3010, C++3051, C++3137, C++3717",[1379,1683,1684],{},[1494,1685],{},[1348,1687,1689,1695,1700,1705],{"className":1688},[1443],[1379,1690,1691],{},[51,1692,1694],{"href":1693},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fklocwork","Klocwork",[1379,1696,1697],{},[1453,1698,1669],{"className":1699},[1456],[1379,1701,1702],{},[1281,1703,1704],{},"CWARN.CMPCHR.EOF",[1379,1706,1707],{},[1494,1708],{},[1348,1710,1712,1718,1724,1731],{"className":1711},[1471],[1379,1713,1714],{},[51,1715,1717],{"href":1716},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fldra","LDRA tool suite",[1379,1719,1720],{},[1453,1721,1723],{"className":1722},[1456],"9.7.1",[1379,1725,1726],{},[1281,1727,1728,1729],{},"662 S",[1494,1730],{},[1379,1732,1733],{},"Fully implemented",[1348,1735,1737,1743,1748,1755],{"className":1736},[1443],[1379,1738,1739],{},[51,1740,1742],{"href":1741},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fparasoft","Parasoft C\u002FC++test",[1379,1744,1745],{},[1453,1746,1669],{"className":1747},[1456],[1379,1749,1750],{},[39,1751,1752],{},[1281,1753,1754],{},"CERT_C-FIO34-a",[1379,1756,1757],{},[39,1758,1759],{},"The macro EOF should be compared with the unmodified return value from the Standard Library function",[1348,1761,1763,1771,1779,1791],{"className":1762},[1471],[1379,1764,1765],{},[39,1766,1767],{},[51,1768,1770],{"href":1769},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpolyspace-bug-finder","Polyspace Bug Finder",[1379,1772,1773],{},[1453,1774,1776],{"className":1775},[1456],[39,1777,1778],{},"R2025b",[1379,1780,1781,1787],{},[39,1782,1783],{},[51,1784,1786],{"href":1785},"https:\u002F\u002Fwww.mathworks.com\u002Fhelp\u002Fbugfinder\u002Fref\u002Fcertcrulefio34c.html","CERT C: Rule FIO34-C",[39,1788,1789],{},[1494,1790],{},[1379,1792,1793],{},[39,1794,1795],{},"Checks for character values absorbed into EOF (rule partially covered)",[1348,1797,1799,1805,1808,1814],{"className":1798},[1443],[1379,1800,1801],{},[51,1802,1804],{"href":1803},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fsplint","Splint",[1379,1806,1807],{},"3.1.1",[1379,1809,1810],{},[39,1811,1812],{},[1494,1813],{},[1379,1815,1816],{},[39,1817,1818],{},[1494,1819],{},[1348,1821,1823,1829,1836,1842],{"className":1822},[1471],[1379,1824,1825],{},[51,1826,1828],{"href":1827},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Frulechecker","RuleChecker",[1379,1830,1831],{},[1453,1832,1834],{"className":1833},[1456],[39,1835,1457],{},[1379,1837,1838],{},[39,1839,1840],{},[1281,1841,1464],{},[1379,1843,1844],{},"Partially checked",[1406,1846,1848],{"id":1847},"related-vulnerabilities","Related Vulnerabilities",[39,1850,1851,1852,1856,1857,60],{},"Search for ",[51,1853,1855],{"href":1854},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-vulnerability","vulnerabilities"," resulting from the violation of this rule on the ",[51,1858,1861],{"href":1859,"rel":1860},"https:\u002F\u002Fwww.kb.cert.org\u002Fvulnotes\u002Fbymetric?searchview&query=FIELD+KEYWORDS+contains+FIO34-C",[1336],"CERT website",[227,1863,1865],{"id":1864},"related-guidelines","Related Guidelines",[39,1867,1868,1872],{},[51,1869,1871],{"href":1870},"\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fhow-this-coding-standard-is-organized#HowthisCodingStandardisOrganized-RelatedGuidelines","Key here"," (explains table format and definitions)",[1340,1874,1875,1885],{},[1344,1876,1877],{},[1348,1878,1879,1881,1883],{},[1352,1880],{},[1352,1882],{},[1352,1884],{},[1374,1886,1887,1898,1913,1927,1942,1955],{},[1348,1888,1889,1892,1895],{},[1379,1890,1891],{},"Taxonomy",[1379,1893,1894],{},"Taxonomy item",[1379,1896,1897],{},"Relationship",[1348,1899,1900,1905,1910],{},[1379,1901,1902],{},[51,1903,1904],{"href":17},"CERT C Secure Coding Standard",[1379,1906,1907],{},[51,1908,83],{"href":1909},"#",[1379,1911,1912],{},"Prior to 2018-01-12: CERT: Unspecified Relationship",[1348,1914,1915,1919,1925],{},[1379,1916,1917],{},[51,1918,1904],{"href":17},[1379,1920,1921],{},[51,1922,1924],{"href":1923},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int\u002Fint31-c","INT31-C. Ensure that integer conversions do not result in lost or misinterpreted data",[1379,1926,1912],{},[1348,1928,1929,1934,1940],{},[1379,1930,1931],{},[51,1932,1933],{"href":23},"CERT Oracle Secure Coding Standard for Java",[1379,1935,1936],{},[51,1937,1939],{"href":1938},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio08-j","FIO08-J. Use an int to capture the return value of methods that read a character or byte",[1379,1941,1912],{},[1348,1943,1944,1950,1953],{},[1379,1945,1946],{},[51,1947,1949],{"href":1948},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-ISO\u002FIECTS17961","ISO\u002FIEC TS 17961:2013",[1379,1951,1952],{},"Using character values that are indistinguishable from EOF [chreof]",[1379,1954,1912],{},[1348,1956,1957,1964,1971],{},[1379,1958,1959],{},[51,1960,1963],{"href":1961,"rel":1962},"http:\u002F\u002Fcwe.mitre.org\u002F",[1336],"CWE 2.11",[1379,1965,1966],{},[51,1967,1970],{"href":1968,"rel":1969},"https:\u002F\u002Fcwe.mitre.org\u002Fdata\u002Findex.html197.html",[1336],"CWE-197",[1379,1972,1973],{},"2017-06-14: CERT: Rule subset of CWE",[227,1975,1977],{"id":1976},"cert-cwe-mapping-notes","CERT-CWE Mapping Notes",[39,1979,1980,1983],{},[51,1981,1871],{"href":1982},"\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fhow-this-coding-standard-is-organized#HowthisCodingStandardisOrganized-CERT-CWEMappingNotes"," for mapping notes",[1406,1985,1987],{"id":1986},"cwe-197-and-fio34-c","CWE-197 and FIO34-C",[39,1989,1990],{},"Independent( FLP34-C, INT31-C) FIO34-C = Subset( INT31-C)",[39,1992,1993],{},"Therefore: FIO34-C = Subset( CWE-197)",[227,1995,1997],{"id":1996},"bibliography","Bibliography",[1340,1999,2000,2008],{},[1344,2001,2002],{},[1348,2003,2004,2006],{},[1352,2005],{},[1352,2007],{},[1374,2009,2010,2025,2036],{},[1348,2011,2012,2018],{},[1379,2013,2014,2015,2017],{},"[ ",[51,2016,214],{"href":213}," ]",[1379,2019,2020,2021,2024],{},"Section 1.2, \"\u003C ",[43,2022,2023],{},"stdio.h"," > and Character Types\"",[1348,2026,2027,2033],{},[1379,2028,2014,2029,2017],{},[51,2030,2032],{"href":2031},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-NIST06","NIST 2006",[1379,2034,2035],{},"SAMATE Reference Dataset Test Case ID 000-000-088",[1348,2037,2038,2044],{},[1379,2039,2014,2040,2017],{},[51,2041,2043],{"href":2042},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-Summit95","Summit 2005",[1379,2045,2046],{},"Question 12.2",[2048,2049],"hr",{},[39,2051,2052,2059,2060,2059,2066],{},[51,2053,2055],{"href":2054},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio32-c",[2056,2057],"img",{"src":2058},"\u002Fattachments\u002F87152044\u002F88034188.png"," ",[51,2061,2063],{"href":2062},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002F",[2056,2064],{"src":2065},"\u002Fattachments\u002F87152044\u002F88034190.png",[51,2067,2069],{"href":2068},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio37-c",[2056,2070],{"src":2071},"\u002Fattachments\u002F87152044\u002F88034189.png",[2073,2074,2075],"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 .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);}html pre.shiki code .s7F3e, html code.shiki .s7F3e{--shiki-default:#005CC5;--shiki-dark:#79B8FF;--shiki-sepia:#AE81FF}html pre.shiki code .s-m8C, html code.shiki .s-m8C{--shiki-default:#005CC5;--shiki-default-font-style:inherit;--shiki-dark:#79B8FF;--shiki-dark-font-style:inherit;--shiki-sepia:#66D9EF;--shiki-sepia-font-style:italic}html pre.shiki code .sOrwc, html code.shiki .sOrwc{--shiki-default:#E36209;--shiki-dark:#FFAB70;--shiki-sepia:#F8F8F2}html pre.shiki code .s8-w5, html code.shiki .s8-w5{--shiki-default:#6A737D;--shiki-dark:#6A737D;--shiki-sepia:#88846F}",{"title":250,"searchDepth":268,"depth":268,"links":2077},[2078,2079,2080,2081,2082,2083,2084,2085,2089,2090,2093],{"id":229,"depth":268,"text":230},{"id":371,"depth":268,"text":372},{"id":490,"depth":268,"text":491},{"id":657,"depth":268,"text":658},{"id":767,"depth":268,"text":768},{"id":1028,"depth":268,"text":372},{"id":1276,"depth":268,"text":1277},{"id":1321,"depth":268,"text":1322,"children":2086},[2087,2088],{"id":1408,"depth":275,"text":1409},{"id":1847,"depth":275,"text":1848},{"id":1864,"depth":268,"text":1865},{"id":1976,"depth":268,"text":1977,"children":2091},[2092],{"id":1986,"depth":275,"text":1987},{"id":1996,"depth":268,"text":1997},"The EOF macro represents a negative value that is used to indicate that the file is exhausted and no data remains when reading data from a file. EOF is an example of an in-band error indicator . In-band error indicators are problematic to work with, and the creation of new in-band-error indicators is discouraged by ERR02-C. Avoid in-band error indicators .","md",{"tags":2097},[2098,2099,2100,2101,2102,2103],"in-cpp","nptc","nptc-complexity","android-unknown","fio","rule","\u002Fsei-cert-c-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio34-c",{"title":30,"description":2094},"4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F04.fio34-c","bKTqJGNEFV8zLGzMRVhK2hfWwF5lnlTWtO_N2HdP_dQ",[2109,2112],{"title":2110,"path":2054,"stem":2111,"children":-1},"FIO32-C. Do not perform operations on devices that are only appropriate for files","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F03.fio32-c",{"title":2113,"path":2068,"stem":2114,"children":-1},"FIO37-C. Do not assume that fgets() or fgetws() returns a nonempty string when successful","4.sei-cert-c-coding-standard\u002F03.rules\u002F11.input-output-fio\u002F05.fio37-c",[2116],{"title":2117,"path":2118,"stem":2119,"children":2120},"SEI CERT C Coding Standard","\u002Fsei-cert-c-coding-standard","4.sei-cert-c-coding-standard\u002F01.index",[2121,2122,2194,2771,3043,3057,3061,3065,3069,3880],{"title":2117,"path":2118,"stem":2119},{"title":2123,"path":2124,"stem":2125,"children":2126},"Front Matter","\u002Fsei-cert-c-coding-standard\u002Ffront-matter","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F1.index",[2127,2128],{"title":2123,"path":2124,"stem":2125},{"title":2129,"path":2130,"stem":2131,"children":2132},"Introduction","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F01.index",[2133,2134,2138,2142,2146,2150,2154,2158,2162,2166,2170,2174,2178,2182,2186,2190],{"title":2129,"path":2130,"stem":2131},{"title":2135,"path":2136,"stem":2137},"Scope","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fscope","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F01.scope",{"title":2139,"path":2140,"stem":2141},"Audience","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Faudience","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F02.audience",{"title":2143,"path":2144,"stem":2145},"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":2147,"path":2148,"stem":2149},"History","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fhistory","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F04.history",{"title":2151,"path":2152,"stem":2153},"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":2155,"path":2156,"stem":2157},"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":2159,"path":2160,"stem":2161},"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":2163,"path":2164,"stem":2165},"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":2167,"path":2168,"stem":2169},"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":2171,"path":2172,"stem":2173},"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":2175,"path":2176,"stem":2177},"Usage","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fusage","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F11.usage",{"title":2179,"path":2180,"stem":2181},"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":2183,"path":2184,"stem":2185},"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":2187,"path":2188,"stem":2189},"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":2191,"path":2192,"stem":2193},"Acknowledgments","\u002Fsei-cert-c-coding-standard\u002Ffront-matter\u002Fintroduction\u002Facknowledgments","4.sei-cert-c-coding-standard\u002F02.front-matter\u002F2.introduction\u002F15.acknowledgments",{"title":2195,"path":2196,"stem":2197,"children":2198},"Rules","\u002Fsei-cert-c-coding-standard\u002Frules","4.sei-cert-c-coding-standard\u002F03.rules\u002F01.index",[2199,2200,2204,2234,2262,2324,2362,2388,2410,2476,2502,2551,2583,2613,2623,2661,2731,2749],{"title":2195,"path":2196,"stem":2197},{"title":2201,"path":2202,"stem":2203},"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":2205,"path":2206,"stem":2207,"children":2208},"Arrays (ARR)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Farrays-arr","4.sei-cert-c-coding-standard\u002F03.rules\u002F03.arrays-arr\u002F1.index",[2209,2210,2214,2218,2222,2226,2230],{"title":2205,"path":2206,"stem":2207},{"title":2211,"path":2212,"stem":2213},"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":2215,"path":2216,"stem":2217},"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":2219,"path":2220,"stem":2221},"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":2223,"path":2224,"stem":2225},"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":2227,"path":2228,"stem":2229},"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":2231,"path":2232,"stem":2233},"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":2235,"path":2236,"stem":2237,"children":2238},"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",[2239,2240,2244,2248,2252,2254,2258],{"title":2235,"path":2236,"stem":2237},{"title":2241,"path":2242,"stem":2243},"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":2245,"path":2246,"stem":2247},"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":2249,"path":2250,"stem":2251},"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":653,"path":652,"stem":2253},"4.sei-cert-c-coding-standard\u002F03.rules\u002F04.characters-and-strings-str\u002F5.str34-c",{"title":2255,"path":2256,"stem":2257},"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":2259,"path":2260,"stem":2261},"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":2263,"path":2264,"stem":2265,"children":2266},"Concurrency (CON)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fconcurrency-con","4.sei-cert-c-coding-standard\u002F03.rules\u002F05.concurrency-con\u002F01.index",[2267,2268,2272,2276,2280,2284,2288,2292,2296,2300,2304,2308,2312,2316,2320],{"title":2263,"path":2264,"stem":2265},{"title":2269,"path":2270,"stem":2271},"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":2273,"path":2274,"stem":2275},"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":2277,"path":2278,"stem":2279},"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":2281,"path":2282,"stem":2283},"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":2285,"path":2286,"stem":2287},"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":2289,"path":2290,"stem":2291},"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":2293,"path":2294,"stem":2295},"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":2297,"path":2298,"stem":2299},"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":2301,"path":2302,"stem":2303},"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":2305,"path":2306,"stem":2307},"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":2309,"path":2310,"stem":2311},"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":2313,"path":2314,"stem":2315},"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":2317,"path":2318,"stem":2319},"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":2321,"path":2322,"stem":2323},"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":2325,"path":2326,"stem":2327,"children":2328},"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",[2329,2330,2334,2338,2342,2346,2350,2354,2358],{"title":2325,"path":2326,"stem":2327},{"title":2331,"path":2332,"stem":2333},"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":2335,"path":2336,"stem":2337},"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":2339,"path":2340,"stem":2341},"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":2343,"path":2344,"stem":2345},"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":2347,"path":2348,"stem":2349},"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":2351,"path":2352,"stem":2353},"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":2355,"path":2356,"stem":2357},"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":2359,"path":2360,"stem":2361},"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":2363,"path":2364,"stem":2365,"children":2366},"Environment (ENV)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fenvironment-env","4.sei-cert-c-coding-standard\u002F03.rules\u002F07.environment-env\u002F1.index",[2367,2368,2372,2376,2380,2384],{"title":2363,"path":2364,"stem":2365},{"title":2369,"path":2370,"stem":2371},"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":2373,"path":2374,"stem":2375},"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":2377,"path":2378,"stem":2379},"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":2381,"path":2382,"stem":2383},"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":2385,"path":2386,"stem":2387},"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":2389,"path":2390,"stem":2391,"children":2392},"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",[2393,2394,2398,2402,2406],{"title":2389,"path":2390,"stem":2391},{"title":2395,"path":2396,"stem":2397},"ERR30-C. Take care when reading errno","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr30-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F2.err30-c",{"title":2399,"path":2400,"stem":2401},"ERR32-C. Do not rely on indeterminate values of errno","\u002Fsei-cert-c-coding-standard\u002Frules\u002Ferror-handling-err\u002Ferr32-c","4.sei-cert-c-coding-standard\u002F03.rules\u002F08.error-handling-err\u002F3.err32-c",{"title":2403,"path":2404,"stem":2405},"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":2407,"path":2408,"stem":2409},"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":2411,"path":2412,"stem":2413,"children":2414},"Expressions (EXP)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fexpressions-exp","4.sei-cert-c-coding-standard\u002F03.rules\u002F09.expressions-exp\u002F01.index",[2415,2416,2420,2424,2428,2432,2436,2440,2444,2448,2452,2456,2460,2464,2468,2472],{"title":2411,"path":2412,"stem":2413},{"title":2417,"path":2418,"stem":2419},"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":2421,"path":2422,"stem":2423},"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":2425,"path":2426,"stem":2427},"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":2429,"path":2430,"stem":2431},"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":2433,"path":2434,"stem":2435},"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":2437,"path":2438,"stem":2439},"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":2441,"path":2442,"stem":2443},"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":2445,"path":2446,"stem":2447},"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":2449,"path":2450,"stem":2451},"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":2453,"path":2454,"stem":2455},"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":2457,"path":2458,"stem":2459},"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":2461,"path":2462,"stem":2463},"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":2465,"path":2466,"stem":2467},"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":2469,"path":2470,"stem":2471},"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":2473,"path":2474,"stem":2475},"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":2477,"path":2478,"stem":2479,"children":2480},"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",[2481,2482,2486,2490,2494,2498],{"title":2477,"path":2478,"stem":2479},{"title":2483,"path":2484,"stem":2485},"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":2487,"path":2488,"stem":2489},"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":2491,"path":2492,"stem":2493},"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":2495,"path":2496,"stem":2497},"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":2499,"path":2500,"stem":2501},"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":2503,"path":2504,"stem":2505,"children":2506},"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",[2507,2508,2512,2513,2514,2515,2519,2523,2527,2531,2535,2539,2543,2547],{"title":2503,"path":2504,"stem":2505},{"title":2509,"path":2510,"stem":2511},"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":2110,"path":2054,"stem":2111},{"title":30,"path":2104,"stem":2106},{"title":2113,"path":2068,"stem":2114},{"title":2516,"path":2517,"stem":2518},"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":2520,"path":2521,"stem":2522},"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":2524,"path":2525,"stem":2526},"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":2528,"path":2529,"stem":2530},"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":2532,"path":2533,"stem":2534},"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":2536,"path":2537,"stem":2538},"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":2540,"path":2541,"stem":2542},"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":2544,"path":2545,"stem":2546},"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":2548,"path":2549,"stem":2550},"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":2552,"path":2553,"stem":2554,"children":2555},"Integers (INT)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fintegers-int","4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F1.index",[2556,2557,2561,2563,2567,2571,2575,2579],{"title":2552,"path":2553,"stem":2554},{"title":2558,"path":2559,"stem":2560},"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":1924,"path":1923,"stem":2562},"4.sei-cert-c-coding-standard\u002F03.rules\u002F12.integers-int\u002F3.int31-c",{"title":2564,"path":2565,"stem":2566},"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":2568,"path":2569,"stem":2570},"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":2572,"path":2573,"stem":2574},"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":2576,"path":2577,"stem":2578},"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":2580,"path":2581,"stem":2582},"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":2584,"path":2585,"stem":2586,"children":2587},"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",[2588,2589,2593,2597,2601,2605,2609],{"title":2584,"path":2585,"stem":2586},{"title":2590,"path":2591,"stem":2592},"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":2594,"path":2595,"stem":2596},"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":2598,"path":2599,"stem":2600},"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":2602,"path":2603,"stem":2604},"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":2606,"path":2607,"stem":2608},"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":2610,"path":2611,"stem":2612},"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":2614,"path":2615,"stem":2616,"children":2617},"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",[2618,2619],{"title":2614,"path":2615,"stem":2616},{"title":2620,"path":2621,"stem":2622},"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":2624,"path":2625,"stem":2626,"children":2627},"Miscellaneous (MSC)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fmiscellaneous-msc","4.sei-cert-c-coding-standard\u002F03.rules\u002F15.miscellaneous-msc\u002F1.index",[2628,2629,2633,2637,2641,2645,2649,2653,2657],{"title":2624,"path":2625,"stem":2626},{"title":2630,"path":2631,"stem":2632},"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":2634,"path":2635,"stem":2636},"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":2638,"path":2639,"stem":2640},"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":2642,"path":2643,"stem":2644},"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":2646,"path":2647,"stem":2648},"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":2650,"path":2651,"stem":2652},"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":2654,"path":2655,"stem":2656},"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":2658,"path":2659,"stem":2660},"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":2662,"path":2663,"stem":2664,"children":2665},"POSIX (POS)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fposix-pos","4.sei-cert-c-coding-standard\u002F03.rules\u002F16.posix-pos\u002F01.index",[2666,2667,2671,2675,2679,2683,2687,2691,2695,2699,2703,2707,2711,2715,2719,2723,2727],{"title":2662,"path":2663,"stem":2664},{"title":2668,"path":2669,"stem":2670},"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":2672,"path":2673,"stem":2674},"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":2676,"path":2677,"stem":2678},"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":2680,"path":2681,"stem":2682},"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":2684,"path":2685,"stem":2686},"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":2688,"path":2689,"stem":2690},"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":2692,"path":2693,"stem":2694},"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":2696,"path":2697,"stem":2698},"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":2700,"path":2701,"stem":2702},"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":2704,"path":2705,"stem":2706},"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":2708,"path":2709,"stem":2710},"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":2712,"path":2713,"stem":2714},"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":2716,"path":2717,"stem":2718},"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":2720,"path":2721,"stem":2722},"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":2724,"path":2725,"stem":2726},"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":2728,"path":2729,"stem":2730},"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":2732,"path":2733,"stem":2734,"children":2735},"Preprocessor (PRE)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fpreprocessor-pre","4.sei-cert-c-coding-standard\u002F03.rules\u002F17.preprocessor-pre\u002F1.index",[2736,2737,2741,2745],{"title":2732,"path":2733,"stem":2734},{"title":2738,"path":2739,"stem":2740},"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":2742,"path":2743,"stem":2744},"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":2746,"path":2747,"stem":2748},"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":2750,"path":2751,"stem":2752,"children":2753},"Signals (SIG)","\u002Fsei-cert-c-coding-standard\u002Frules\u002Fsignals-sig","4.sei-cert-c-coding-standard\u002F03.rules\u002F18.signals-sig\u002F1.index",[2754,2755,2759,2763,2767],{"title":2750,"path":2751,"stem":2752},{"title":2756,"path":2757,"stem":2758},"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":2760,"path":2761,"stem":2762},"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":2764,"path":2765,"stem":2766},"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":2768,"path":2769,"stem":2770},"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":2772,"path":2773,"stem":2774,"children":2775},"Back Matter","\u002Fsei-cert-c-coding-standard\u002Fback-matter","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F1.index",[2776,2777,2781,2785,2789,2793,2982,3039],{"title":2772,"path":2773,"stem":2774},{"title":2778,"path":2779,"stem":2780},"AA. Bibliography","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Faa-bibliography","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F2.aa-bibliography",{"title":2782,"path":2783,"stem":2784},"BB. Definitions","\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fbb-definitions","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F3.bb-definitions",{"title":2786,"path":2787,"stem":2788},"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":2790,"path":2791,"stem":2792},"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":2794,"path":2795,"stem":2796,"children":2797},"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",[2798,2799,2801,2805,2807,2811,2815,2819,2823,2827,2831,2835,2839,2841,2845,2847,2851,2855,2857,2861,2865,2867,2871,2875,2879,2883,2887,2889,2893,2895,2899,2902,2906,2909,2913,2917,2921,2923,2927,2931,2935,2938,2942,2946,2948,2952,2956,2960,2964,2968,2970,2974,2978],{"title":2794,"path":2795,"stem":2796},{"title":1449,"path":1448,"stem":2800},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F02.astree",{"title":2802,"path":2803,"stem":2804},"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":1477,"path":1476,"stem":2806},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F04.axivion-bauhaus-suite",{"title":2808,"path":2809,"stem":2810},"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":2812,"path":2813,"stem":2814},"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":2816,"path":2817,"stem":2818},"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":2820,"path":2821,"stem":2822},"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":2824,"path":2825,"stem":2826},"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":2828,"path":2829,"stem":2830},"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":2832,"path":2833,"stem":2834},"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":2836,"path":2837,"stem":2838},"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":1504,"path":1503,"stem":2840},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F13.codesonar",{"title":2842,"path":2843,"stem":2844},"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":1554,"path":1553,"stem":2846},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F15.coverity",{"title":2848,"path":2849,"stem":2850},"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":2852,"path":2853,"stem":2854},"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":1601,"path":1600,"stem":2856},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F18.cppcheck-premium",{"title":2858,"path":2859,"stem":2860},"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":2862,"path":2863,"stem":2864},"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":1635,"path":1634,"stem":2866},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F21.eclair",{"title":2868,"path":2869,"stem":2870},"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":2872,"path":2873,"stem":2874},"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":2876,"path":2877,"stem":2878},"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":2880,"path":2881,"stem":2882},"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":2884,"path":2885,"stem":2886},"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":1661,"path":1660,"stem":2888},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F27.helix-qac",{"title":2890,"path":2891,"stem":2892},"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":1694,"path":1693,"stem":2894},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F29.klocwork",{"title":2896,"path":2897,"stem":2898},"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":2900,"path":1716,"stem":2901},"LDRA","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F31.ldra",{"title":2903,"path":2904,"stem":2905},"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":2907,"path":1741,"stem":2908},"Parasoft","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F33.parasoft",{"title":2910,"path":2911,"stem":2912},"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":2914,"path":2915,"stem":2916},"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":2918,"path":2919,"stem":2920},"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":1770,"path":1769,"stem":2922},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F37.polyspace-bug-finder",{"title":2924,"path":2925,"stem":2926},"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":2928,"path":2929,"stem":2930},"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":2932,"path":2933,"stem":2934},"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":2936,"path":1526,"stem":2937},"Rose","4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F41.rose",{"title":2939,"path":2940,"stem":2941},"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":2943,"path":2944,"stem":2945},"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":1828,"path":1827,"stem":2947},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F44.rulechecker",{"title":2949,"path":2950,"stem":2951},"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":2953,"path":2954,"stem":2955},"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":2957,"path":2958,"stem":2959},"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":2961,"path":2962,"stem":2963},"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":2965,"path":2966,"stem":2967},"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":1804,"path":1803,"stem":2969},"4.sei-cert-c-coding-standard\u002F04.back-matter\u002F6.ee-analyzers\u002F50.splint",{"title":2971,"path":2972,"stem":2973},"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":2975,"path":2976,"stem":2977},"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":2979,"path":2980,"stem":2981},"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":2983,"path":2984,"stem":2985,"children":2986},"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",[2987,2988,2992,2996,3000,3004,3008,3012,3016,3020,3023,3027,3031,3035],{"title":2983,"path":2984,"stem":2985},{"title":2989,"path":2990,"stem":2991},"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":2993,"path":2994,"stem":2995},"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":2997,"path":2998,"stem":2999},"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":3001,"path":3002,"stem":3003},"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":3005,"path":3006,"stem":3007},"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":3009,"path":3010,"stem":3011},"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":3013,"path":3014,"stem":3015},"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":3017,"path":3018,"stem":3019},"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":3017,"path":3021,"stem":3022},"\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":3024,"path":3025,"stem":3026},"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":3028,"path":3029,"stem":3030},"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":3032,"path":3033,"stem":3034},"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":3036,"path":3037,"stem":3038},"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":3040,"path":3041,"stem":3042},"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":3044,"path":3045,"stem":3046,"children":3047},"Admin","\u002Fsei-cert-c-coding-standard\u002Fadmin","4.sei-cert-c-coding-standard\u002F05.admin\u002F1.index",[3048,3049,3053],{"title":3044,"path":3045,"stem":3046},{"title":3050,"path":3051,"stem":3052},"TODO List","\u002Fsei-cert-c-coding-standard\u002Fadmin\u002Ftodo-list","4.sei-cert-c-coding-standard\u002F05.admin\u002F2.todo-list",{"title":3054,"path":3055,"stem":3056},"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":3058,"path":3059,"stem":3060},"Coding Style Guidelines","\u002Fsei-cert-c-coding-standard\u002Fcoding-style-guidelines","4.sei-cert-c-coding-standard\u002F05.coding-style-guidelines",{"title":3062,"path":3063,"stem":3064},"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":3066,"path":3067,"stem":3068},"Wiki Contents","\u002Fsei-cert-c-coding-standard\u002Fwiki-contents","4.sei-cert-c-coding-standard\u002F06.wiki-contents",{"title":3070,"path":3071,"stem":3072,"children":3073},"Recommendations","\u002Fsei-cert-c-coding-standard\u002Frecommendations","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F01.index",[3074,3075,3116,3133,3176,3217,3314,3331,3362,3431,3468,3553,3618,3667,3692,3785,3806,3863],{"title":3070,"path":3071,"stem":3072},{"title":2201,"path":3076,"stem":3077,"children":3078},"\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",[3079,3080,3084,3088,3092,3096,3100,3104,3108,3112],{"title":2201,"path":3076,"stem":3077},{"title":3081,"path":3082,"stem":3083},"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":3085,"path":3086,"stem":3087},"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":3089,"path":3090,"stem":3091},"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":3093,"path":3094,"stem":3095},"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":3097,"path":3098,"stem":3099},"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":3101,"path":3102,"stem":3103},"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":3105,"path":3106,"stem":3107},"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":3109,"path":3110,"stem":3111},"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":3113,"path":3114,"stem":3115},"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":2205,"path":3117,"stem":3118,"children":3119},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Farrays-arr","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F03.arrays-arr\u002F1.index",[3120,3121,3125,3129],{"title":2205,"path":3117,"stem":3118},{"title":3122,"path":3123,"stem":3124},"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":3126,"path":3127,"stem":3128},"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":3130,"path":3131,"stem":3132},"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":2235,"path":3134,"stem":3135,"children":3136},"\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",[3137,3138,3140,3144,3148,3152,3156,3160,3164,3168,3172],{"title":2235,"path":3134,"stem":3135},{"title":83,"path":82,"stem":3139},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F04.characters-and-strings-str\u002F02.str00-c",{"title":3141,"path":3142,"stem":3143},"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":3145,"path":3146,"stem":3147},"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":3149,"path":3150,"stem":3151},"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":3153,"path":3154,"stem":3155},"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":3157,"path":3158,"stem":3159},"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":3161,"path":3162,"stem":3163},"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":3165,"path":3166,"stem":3167},"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":3169,"path":3170,"stem":3171},"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":3173,"path":3174,"stem":3175},"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":2263,"path":3177,"stem":3178,"children":3179},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fconcurrency-con","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F05.concurrency-con\u002F01.index",[3180,3181,3185,3189,3193,3197,3201,3205,3209,3213],{"title":2263,"path":3177,"stem":3178},{"title":3182,"path":3183,"stem":3184},"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":3186,"path":3187,"stem":3188},"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":3190,"path":3191,"stem":3192},"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":3194,"path":3195,"stem":3196},"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":3198,"path":3199,"stem":3200},"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":3202,"path":3203,"stem":3204},"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":3206,"path":3207,"stem":3208},"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":3210,"path":3211,"stem":3212},"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":3214,"path":3215,"stem":3216},"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":2325,"path":3218,"stem":3219,"children":3220},"\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",[3221,3222,3226,3230,3234,3238,3242,3246,3250,3254,3258,3262,3266,3270,3274,3278,3282,3286,3290,3294,3298,3302,3306,3310],{"title":2325,"path":3218,"stem":3219},{"title":3223,"path":3224,"stem":3225},"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":3227,"path":3228,"stem":3229},"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":3231,"path":3232,"stem":3233},"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":3235,"path":3236,"stem":3237},"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":3239,"path":3240,"stem":3241},"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":3243,"path":3244,"stem":3245},"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":3247,"path":3248,"stem":3249},"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":3251,"path":3252,"stem":3253},"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":3255,"path":3256,"stem":3257},"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":3259,"path":3260,"stem":3261},"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":3263,"path":3264,"stem":3265},"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":3267,"path":3268,"stem":3269},"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":3271,"path":3272,"stem":3273},"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":3275,"path":3276,"stem":3277},"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":3279,"path":3280,"stem":3281},"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":3283,"path":3284,"stem":3285},"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":3287,"path":3288,"stem":3289},"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":3291,"path":3292,"stem":3293},"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":3295,"path":3296,"stem":3297},"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":3299,"path":3300,"stem":3301},"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":3303,"path":3304,"stem":3305},"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":3307,"path":3308,"stem":3309},"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":3311,"path":3312,"stem":3313},"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":2363,"path":3315,"stem":3316,"children":3317},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fenvironment-env","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F07.environment-env\u002F1.index",[3318,3319,3323,3327],{"title":2363,"path":3315,"stem":3316},{"title":3320,"path":3321,"stem":3322},"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":3324,"path":3325,"stem":3326},"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":3328,"path":3329,"stem":3330},"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":2389,"path":3332,"stem":3333,"children":3334},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ferror-handling-err","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F1.index",[3335,3336,3340,3344,3346,3350,3354,3358],{"title":2389,"path":3332,"stem":3333},{"title":3337,"path":3338,"stem":3339},"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":3341,"path":3342,"stem":3343},"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":59,"path":58,"stem":3345},"4.sei-cert-c-coding-standard\u002F08.recommendations\u002F08.error-handling-err\u002F4.err02-c",{"title":3347,"path":3348,"stem":3349},"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":3351,"path":3352,"stem":3353},"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":3355,"path":3356,"stem":3357},"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":3359,"path":3360,"stem":3361},"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":2411,"path":3363,"stem":3364,"children":3365},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F01.index",[3366,3367,3371,3375,3379,3383,3387,3391,3395,3399,3403,3407,3411,3415,3419,3423,3427],{"title":2411,"path":3363,"stem":3364},{"title":3368,"path":3369,"stem":3370},"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":3372,"path":3373,"stem":3374},"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":3376,"path":3377,"stem":3378},"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":3380,"path":3381,"stem":3382},"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":3384,"path":3385,"stem":3386},"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":3388,"path":3389,"stem":3390},"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":3392,"path":3393,"stem":3394},"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":3396,"path":3397,"stem":3398},"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":3400,"path":3401,"stem":3402},"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":3404,"path":3405,"stem":3406},"EXP12-C. Do not ignore values returned by functions","\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fexpressions-exp\u002Fexp12-c","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F09.expressions-exp\u002F11.exp12-c",{"title":3408,"path":3409,"stem":3410},"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":3412,"path":3413,"stem":3414},"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":3416,"path":3417,"stem":3418},"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":3420,"path":3421,"stem":3422},"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":3424,"path":3425,"stem":3426},"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":3428,"path":3429,"stem":3430},"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":2477,"path":3432,"stem":3433,"children":3434},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Ffloating-point-flp","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F10.floating-point-flp\u002F1.index",[3435,3436,3440,3444,3448,3452,3456,3460,3464],{"title":2477,"path":3432,"stem":3433},{"title":3437,"path":3438,"stem":3439},"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":3441,"path":3442,"stem":3443},"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":3445,"path":3446,"stem":3447},"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":3449,"path":3450,"stem":3451},"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":3453,"path":3454,"stem":3455},"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":3457,"path":3458,"stem":3459},"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":3461,"path":3462,"stem":3463},"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":3465,"path":3466,"stem":3467},"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":2503,"path":3469,"stem":3470,"children":3471},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Finput-output-fio","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F11.input-output-fio\u002F01.index",[3472,3473,3477,3481,3485,3489,3493,3497,3501,3505,3509,3513,3517,3521,3525,3529,3533,3537,3541,3545,3549],{"title":2503,"path":3469,"stem":3470},{"title":3474,"path":3475,"stem":3476},"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":3478,"path":3479,"stem":3480},"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":3482,"path":3483,"stem":3484},"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":3486,"path":3487,"stem":3488},"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":3490,"path":3491,"stem":3492},"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":3494,"path":3495,"stem":3496},"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":3498,"path":3499,"stem":3500},"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":3502,"path":3503,"stem":3504},"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":3506,"path":3507,"stem":3508},"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":3510,"path":3511,"stem":3512},"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":3514,"path":3515,"stem":3516},"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":3518,"path":3519,"stem":3520},"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":3522,"path":3523,"stem":3524},"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":3526,"path":3527,"stem":3528},"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":3530,"path":3531,"stem":3532},"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":3534,"path":3535,"stem":3536},"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":3538,"path":3539,"stem":3540},"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":3542,"path":3543,"stem":3544},"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":3546,"path":3547,"stem":3548},"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":3550,"path":3551,"stem":3552},"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":2552,"path":3554,"stem":3555,"children":3556},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fintegers-int","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F12.integers-int\u002F01.index",[3557,3558,3562,3566,3570,3574,3578,3582,3586,3590,3594,3598,3602,3606,3610,3614],{"title":2552,"path":3554,"stem":3555},{"title":3559,"path":3560,"stem":3561},"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":3563,"path":3564,"stem":3565},"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":3567,"path":3568,"stem":3569},"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":3571,"path":3572,"stem":3573},"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":3575,"path":3576,"stem":3577},"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":3579,"path":3580,"stem":3581},"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":3583,"path":3584,"stem":3585},"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":3587,"path":3588,"stem":3589},"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":3591,"path":3592,"stem":3593},"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":3595,"path":3596,"stem":3597},"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":3599,"path":3600,"stem":3601},"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":3603,"path":3604,"stem":3605},"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":3607,"path":3608,"stem":3609},"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":3611,"path":3612,"stem":3613},"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":3615,"path":3616,"stem":3617},"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":2584,"path":3619,"stem":3620,"children":3621},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmemory-management-mem","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F13.memory-management-mem\u002F01.index",[3622,3623,3627,3631,3635,3639,3643,3647,3651,3655,3659,3663],{"title":2584,"path":3619,"stem":3620},{"title":3624,"path":3625,"stem":3626},"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":3628,"path":3629,"stem":3630},"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":3632,"path":3633,"stem":3634},"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":3636,"path":3637,"stem":3638},"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":3640,"path":3641,"stem":3642},"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":3644,"path":3645,"stem":3646},"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":3648,"path":3649,"stem":3650},"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":3652,"path":3653,"stem":3654},"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":3656,"path":3657,"stem":3658},"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":3660,"path":3661,"stem":3662},"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":3664,"path":3665,"stem":3666},"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":2614,"path":3668,"stem":3669,"children":3670},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmicrosoft-windows-win","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F14.microsoft-windows-win\u002F1.index",[3671,3672,3676,3680,3684,3688],{"title":2614,"path":3668,"stem":3669},{"title":3673,"path":3674,"stem":3675},"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":3677,"path":3678,"stem":3679},"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":3681,"path":3682,"stem":3683},"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":3685,"path":3686,"stem":3687},"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":3689,"path":3690,"stem":3691},"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":2624,"path":3693,"stem":3694,"children":3695},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fmiscellaneous-msc","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F15.miscellaneous-msc\u002F01.index",[3696,3697,3701,3705,3709,3713,3717,3721,3725,3729,3733,3737,3741,3745,3749,3753,3757,3761,3765,3769,3773,3777,3781],{"title":2624,"path":3693,"stem":3694},{"title":3698,"path":3699,"stem":3700},"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":3702,"path":3703,"stem":3704},"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":3706,"path":3707,"stem":3708},"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":3710,"path":3711,"stem":3712},"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":3714,"path":3715,"stem":3716},"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":3718,"path":3719,"stem":3720},"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":3722,"path":3723,"stem":3724},"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":3726,"path":3727,"stem":3728},"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":3730,"path":3731,"stem":3732},"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":3734,"path":3735,"stem":3736},"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":3738,"path":3739,"stem":3740},"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":3742,"path":3743,"stem":3744},"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":3746,"path":3747,"stem":3748},"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":3750,"path":3751,"stem":3752},"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":3754,"path":3755,"stem":3756},"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":3758,"path":3759,"stem":3760},"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":3762,"path":3763,"stem":3764},"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":3766,"path":3767,"stem":3768},"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":3770,"path":3771,"stem":3772},"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":3774,"path":3775,"stem":3776},"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":3778,"path":3779,"stem":3780},"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":3782,"path":3783,"stem":3784},"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":2662,"path":3786,"stem":3787,"children":3788},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fposix-pos","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F16.posix-pos\u002F1.index",[3789,3790,3794,3798,3802],{"title":2662,"path":3786,"stem":3787},{"title":3791,"path":3792,"stem":3793},"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":3795,"path":3796,"stem":3797},"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":3799,"path":3800,"stem":3801},"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":3803,"path":3804,"stem":3805},"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":2732,"path":3807,"stem":3808,"children":3809},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fpreprocessor-pre","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F17.preprocessor-pre\u002F01.index",[3810,3811,3815,3819,3823,3827,3831,3835,3839,3843,3847,3851,3855,3859],{"title":2732,"path":3807,"stem":3808},{"title":3812,"path":3813,"stem":3814},"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":3816,"path":3817,"stem":3818},"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":3820,"path":3821,"stem":3822},"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":3824,"path":3825,"stem":3826},"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":3828,"path":3829,"stem":3830},"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":3832,"path":3833,"stem":3834},"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":3836,"path":3837,"stem":3838},"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":3840,"path":3841,"stem":3842},"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":3844,"path":3845,"stem":3846},"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":3848,"path":3849,"stem":3850},"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":3852,"path":3853,"stem":3854},"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":3856,"path":3857,"stem":3858},"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":3860,"path":3861,"stem":3862},"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":2750,"path":3864,"stem":3865,"children":3866},"\u002Fsei-cert-c-coding-standard\u002Frecommendations\u002Fsignals-sig","4.sei-cert-c-coding-standard\u002F08.recommendations\u002F18.signals-sig\u002F1.index",[3867,3868,3872,3876],{"title":2750,"path":3864,"stem":3865},{"title":3869,"path":3870,"stem":3871},"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":3873,"path":3874,"stem":3875},"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":3877,"path":3878,"stem":3879},"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":3881,"path":3882,"stem":3883},"CERT manifest files","\u002Fsei-cert-c-coding-standard\u002Fcert-manifest-files","4.sei-cert-c-coding-standard\u002F09.cert-manifest-files",1775657797498]