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