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