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