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