1245 sbdLu->slu_company_id_valid = 1;
1246 sbdLu->slu_company_id = disk->companyId;
1247 }
1248
1249 if (disk->hostIdValid) {
1250 sbdLu->slu_host_id_valid = 1;
1251 sbdLu->slu_host_id = disk->hostId;
1252 }
1253
1254 if (disk->blkSizeValid) {
1255 sbdLu->slu_blksize_valid = 1;
1256 sbdLu->slu_blksize = disk->blkSize;
1257 }
1258
1259 if (disk->writeProtectEnableValid) {
1260 if (disk->writeProtectEnable) {
1261 sbdLu->slu_write_protected = 1;
1262 }
1263 }
1264
1265 if (disk->writebackCacheDisableValid) {
1266 sbdLu->slu_writeback_cache_disable_valid = 1;
1267 if (disk->writebackCacheDisable) {
1268 sbdLu->slu_writeback_cache_disable = 1;
1269 }
1270 }
1271
1272 sbdIoctl.stmf_version = STMF_VERSION_1;
1273 sbdIoctl.stmf_ibuf_size = sbdLu->slu_struct_size;
1274 sbdIoctl.stmf_ibuf = (uint64_t)(unsigned long)sbdLu;
1275 sbdIoctl.stmf_obuf_size = sbdLu->slu_struct_size;
1276 sbdIoctl.stmf_obuf = (uint64_t)(unsigned long)sbdLu;
1277
1278 ioctlRet = ioctl(fd, SBD_IOCTL_CREATE_AND_REGISTER_LU, &sbdIoctl);
1279 if (ioctlRet != 0) {
1280 savedErrno = errno;
1281 switch (savedErrno) {
1282 case EBUSY:
1283 ret = STMF_ERROR_BUSY;
1284 break;
1496 *ret = STMF_ERROR_META_FILE_NAME;
1497 break;
1498 case SBD_RET_DATA_PATH_NOT_ABSOLUTE:
1499 case SBD_RET_DATA_FILE_LOOKUP_FAILED:
1500 case SBD_RET_DATA_FILE_OPEN_FAILED:
1501 case SBD_RET_DATA_FILE_GETATTR_FAILED:
1502 *ret = STMF_ERROR_DATA_FILE_NAME;
1503 break;
1504 case SBD_RET_FILE_SIZE_ERROR:
1505 *ret = STMF_ERROR_FILE_SIZE_INVALID;
1506 break;
1507 case SBD_RET_SIZE_OUT_OF_RANGE:
1508 *ret = STMF_ERROR_SIZE_OUT_OF_RANGE;
1509 break;
1510 case SBD_RET_LU_BUSY:
1511 *ret = STMF_ERROR_LU_BUSY;
1512 break;
1513 case SBD_RET_WRITE_CACHE_SET_FAILED:
1514 *ret = STMF_ERROR_WRITE_CACHE_SET;
1515 break;
1516 case SBD_RET_ACCESS_STATE_FAILED:
1517 *ret = STMF_ERROR_ACCESS_STATE_SET;
1518 break;
1519 default:
1520 *ret = STMF_STATUS_ERROR;
1521 break;
1522 }
1523 }
1524
1525 /*
1526 * Creates a logical unit resource of type STMF_DISK.
1527 *
1528 * No defaults should be set here as all defaults are derived from the
1529 * driver's default settings.
1530 */
1531 static int
1532 createDiskResource(luResourceImpl *hdl)
1533 {
1534 hdl->type = STMF_DISK;
1535
1805 ret = stmfSetLuProp(hdl, prop, propVal);
1806 if (ret != STMF_STATUS_SUCCESS) {
1807 (void) stmfFreeLuResource(hdl);
1808 return (ret);
1809 }
1810 luPropsHdl = hdl;
1811 ret = modifyDiskLu((diskResource *)luPropsHdl->resource, luGuid, fname);
1812 (void) stmfFreeLuResource(hdl);
1813 return (ret);
1814 }
1815
1816 static int
1817 validateModifyDiskProp(uint32_t prop)
1818 {
1819 switch (prop) {
1820 case STMF_LU_PROP_ALIAS:
1821 case STMF_LU_PROP_SIZE:
1822 case STMF_LU_PROP_MGMT_URL:
1823 case STMF_LU_PROP_WRITE_PROTECT:
1824 case STMF_LU_PROP_WRITE_CACHE_DISABLE:
1825 return (STMF_STATUS_SUCCESS);
1826 break;
1827 default:
1828 return (STMF_STATUS_ERROR);
1829 break;
1830 }
1831 }
1832
1833 static int
1834 modifyDiskLu(diskResource *disk, stmfGuid *luGuid, const char *fname)
1835 {
1836 int ret = STMF_STATUS_SUCCESS;
1837 int luAliasLen = 0;
1838 int luMgmtUrlLen = 0;
1839 int mluBufSize = 0;
1840 int bufOffset = 0;
1841 int fd = 0;
1842 int ioctlRet;
1843 int savedErrno;
1844 int fnameSize = 0;
1889 sbdLu->mlu_alias_valid = 1;
1890 sbdLu->mlu_alias_off = bufOffset;
1891 bcopy(disk->luAlias, &(sbdLu->mlu_buf[bufOffset]),
1892 luAliasLen + 1);
1893 bufOffset += luAliasLen + 1;
1894 }
1895
1896 if (disk->luMgmtUrlValid) {
1897 sbdLu->mlu_mgmt_url_valid = 1;
1898 sbdLu->mlu_mgmt_url_off = bufOffset;
1899 bcopy(disk->luMgmtUrl, &(sbdLu->mlu_buf[bufOffset]),
1900 luMgmtUrlLen + 1);
1901 bufOffset += luMgmtUrlLen + 1;
1902 }
1903
1904 if (disk->luSizeValid) {
1905 sbdLu->mlu_lu_size_valid = 1;
1906 sbdLu->mlu_lu_size = disk->luSize;
1907 }
1908
1909 if (disk->writeProtectEnableValid) {
1910 sbdLu->mlu_write_protected_valid = 1;
1911 if (disk->writeProtectEnable) {
1912 sbdLu->mlu_write_protected = 1;
1913 }
1914 }
1915
1916 if (disk->writebackCacheDisableValid) {
1917 sbdLu->mlu_writeback_cache_disable_valid = 1;
1918 if (disk->writebackCacheDisable) {
1919 sbdLu->mlu_writeback_cache_disable = 1;
1920 }
1921 }
1922
1923 if (luGuid) {
1924 bcopy(luGuid, sbdLu->mlu_input_guid, sizeof (stmfGuid));
1925 sbdLu->mlu_by_guid = 1;
1926 } else {
1927 sbdLu->mlu_fname_off = bufOffset;
1928 bcopy(fname, &(sbdLu->mlu_buf[bufOffset]), fnameSize + 1);
2326 diskLu->luAliasValid = B_TRUE;
2327 if (strlcpy(diskLu->luAlias,
2328 (char *)&(sbdProps->slp_buf[
2329 sbdProps->slp_data_fname_off]),
2330 sizeof (diskLu->luAlias)) >=
2331 sizeof (diskLu->luAlias)) {
2332 return (STMF_STATUS_ERROR);
2333 }
2334 }
2335 }
2336
2337 diskLu->vidValid = B_TRUE;
2338 bcopy(sbdProps->slp_vid, diskLu->vid, sizeof (diskLu->vid));
2339
2340 diskLu->pidValid = B_TRUE;
2341 bcopy(sbdProps->slp_pid, diskLu->pid, sizeof (diskLu->pid));
2342
2343 diskLu->revValid = B_TRUE;
2344 bcopy(sbdProps->slp_rev, diskLu->rev, sizeof (diskLu->rev));
2345
2346 diskLu->writeProtectEnableValid = B_TRUE;
2347 if (sbdProps->slp_write_protected) {
2348 diskLu->writeProtectEnable = B_TRUE;
2349 }
2350
2351 diskLu->writebackCacheDisableValid = B_TRUE;
2352 if (sbdProps->slp_writeback_cache_disable_cur) {
2353 diskLu->writebackCacheDisable = B_TRUE;
2354 }
2355
2356 diskLu->blkSizeValid = B_TRUE;
2357 diskLu->blkSize = sbdProps->slp_blksize;
2358
2359 diskLu->luSizeValid = B_TRUE;
2360 diskLu->luSize = sbdProps->slp_lu_size;
2361
2362 diskLu->accessState = sbdProps->slp_access_state;
2363
2364 return (ret);
2365 }
2800 propVal[sizeof (diskLu->pid)] = 0;
2801 break;
2802 case STMF_LU_PROP_WRITE_PROTECT:
2803 if (diskLu->writeProtectEnableValid == B_FALSE) {
2804 return (STMF_ERROR_NO_PROP);
2805 }
2806 if (diskLu->writeProtectEnable) {
2807 if ((reqLen = strlcpy(propVal, "true",
2808 *propLen)) >= *propLen) {
2809 *propLen = reqLen + 1;
2810 return (STMF_ERROR_INVALID_ARG);
2811 }
2812 } else {
2813 if ((reqLen = strlcpy(propVal, "false",
2814 *propLen)) >= *propLen) {
2815 *propLen = reqLen + 1;
2816 return (STMF_ERROR_INVALID_ARG);
2817 }
2818 }
2819 break;
2820 case STMF_LU_PROP_WRITE_CACHE_DISABLE:
2821 if (diskLu->writebackCacheDisableValid == B_FALSE) {
2822 return (STMF_ERROR_NO_PROP);
2823 }
2824 if (diskLu->writebackCacheDisable) {
2825 if ((reqLen = strlcpy(propVal, "true",
2826 *propLen)) >= *propLen) {
2827 *propLen = reqLen + 1;
2828 return (STMF_ERROR_INVALID_ARG);
2829 }
2830 } else {
2831 if ((reqLen = strlcpy(propVal, "false",
2832 *propLen)) >= *propLen) {
2833 *propLen = reqLen + 1;
2834 return (STMF_ERROR_INVALID_ARG);
2835 }
2836 }
2837 break;
2838 default:
2839 ret = STMF_ERROR_INVALID_PROP;
3019 case STMF_LU_PROP_WRITE_PROTECT:
3020 if (strcasecmp(propVal, "TRUE") == 0) {
3021 diskLu->writeProtectEnable = B_TRUE;
3022 } else if (strcasecmp(propVal, "FALSE") == 0) {
3023 diskLu->writeProtectEnable = B_FALSE;
3024 } else {
3025 return (STMF_ERROR_INVALID_ARG);
3026 }
3027 diskLu->writeProtectEnableValid = B_TRUE;
3028 break;
3029 case STMF_LU_PROP_WRITE_CACHE_DISABLE:
3030 if (strcasecmp(propVal, "TRUE") == 0) {
3031 diskLu->writebackCacheDisable = B_TRUE;
3032 } else if (strcasecmp(propVal, "FALSE") == 0) {
3033 diskLu->writebackCacheDisable = B_FALSE;
3034 } else {
3035 return (STMF_ERROR_INVALID_ARG);
3036 }
3037 diskLu->writebackCacheDisableValid = B_TRUE;
3038 break;
3039 case STMF_LU_PROP_ACCESS_STATE:
3040 ret = STMF_ERROR_INVALID_PROP;
3041 break;
3042 default:
3043 ret = STMF_ERROR_INVALID_PROP;
3044 break;
3045 }
3046 return (ret);
3047 }
3048
3049 static int
3050 checkHexUpper(char *buf)
3051 {
3052 int i;
3053
3054 for (i = 0; i < strlen(buf); i++) {
3055 if (isxdigit(buf[i])) {
3056 buf[i] = toupper(buf[i]);
3057 continue;
3058 }
|
1245 sbdLu->slu_company_id_valid = 1;
1246 sbdLu->slu_company_id = disk->companyId;
1247 }
1248
1249 if (disk->hostIdValid) {
1250 sbdLu->slu_host_id_valid = 1;
1251 sbdLu->slu_host_id = disk->hostId;
1252 }
1253
1254 if (disk->blkSizeValid) {
1255 sbdLu->slu_blksize_valid = 1;
1256 sbdLu->slu_blksize = disk->blkSize;
1257 }
1258
1259 if (disk->writeProtectEnableValid) {
1260 if (disk->writeProtectEnable) {
1261 sbdLu->slu_write_protected = 1;
1262 }
1263 }
1264
1265 if (disk->unmapValid) {
1266 sbdLu->slu_unmap_valid = 1;
1267 if (disk->unmap) {
1268 sbdLu->slu_unmap = 1;
1269 }
1270 }
1271
1272 if (disk->writebackCacheDisableValid) {
1273 sbdLu->slu_writeback_cache_disable_valid = 1;
1274 if (disk->writebackCacheDisable) {
1275 sbdLu->slu_writeback_cache_disable = 1;
1276 }
1277 }
1278
1279 sbdIoctl.stmf_version = STMF_VERSION_1;
1280 sbdIoctl.stmf_ibuf_size = sbdLu->slu_struct_size;
1281 sbdIoctl.stmf_ibuf = (uint64_t)(unsigned long)sbdLu;
1282 sbdIoctl.stmf_obuf_size = sbdLu->slu_struct_size;
1283 sbdIoctl.stmf_obuf = (uint64_t)(unsigned long)sbdLu;
1284
1285 ioctlRet = ioctl(fd, SBD_IOCTL_CREATE_AND_REGISTER_LU, &sbdIoctl);
1286 if (ioctlRet != 0) {
1287 savedErrno = errno;
1288 switch (savedErrno) {
1289 case EBUSY:
1290 ret = STMF_ERROR_BUSY;
1291 break;
1503 *ret = STMF_ERROR_META_FILE_NAME;
1504 break;
1505 case SBD_RET_DATA_PATH_NOT_ABSOLUTE:
1506 case SBD_RET_DATA_FILE_LOOKUP_FAILED:
1507 case SBD_RET_DATA_FILE_OPEN_FAILED:
1508 case SBD_RET_DATA_FILE_GETATTR_FAILED:
1509 *ret = STMF_ERROR_DATA_FILE_NAME;
1510 break;
1511 case SBD_RET_FILE_SIZE_ERROR:
1512 *ret = STMF_ERROR_FILE_SIZE_INVALID;
1513 break;
1514 case SBD_RET_SIZE_OUT_OF_RANGE:
1515 *ret = STMF_ERROR_SIZE_OUT_OF_RANGE;
1516 break;
1517 case SBD_RET_LU_BUSY:
1518 *ret = STMF_ERROR_LU_BUSY;
1519 break;
1520 case SBD_RET_WRITE_CACHE_SET_FAILED:
1521 *ret = STMF_ERROR_WRITE_CACHE_SET;
1522 break;
1523 case SBD_RET_UNMAP_SET_FAILED:
1524 *ret = STMF_ERROR_UNMAP_SET;
1525 break;
1526 case SBD_RET_ACCESS_STATE_FAILED:
1527 *ret = STMF_ERROR_ACCESS_STATE_SET;
1528 break;
1529 default:
1530 *ret = STMF_STATUS_ERROR;
1531 break;
1532 }
1533 }
1534
1535 /*
1536 * Creates a logical unit resource of type STMF_DISK.
1537 *
1538 * No defaults should be set here as all defaults are derived from the
1539 * driver's default settings.
1540 */
1541 static int
1542 createDiskResource(luResourceImpl *hdl)
1543 {
1544 hdl->type = STMF_DISK;
1545
1815 ret = stmfSetLuProp(hdl, prop, propVal);
1816 if (ret != STMF_STATUS_SUCCESS) {
1817 (void) stmfFreeLuResource(hdl);
1818 return (ret);
1819 }
1820 luPropsHdl = hdl;
1821 ret = modifyDiskLu((diskResource *)luPropsHdl->resource, luGuid, fname);
1822 (void) stmfFreeLuResource(hdl);
1823 return (ret);
1824 }
1825
1826 static int
1827 validateModifyDiskProp(uint32_t prop)
1828 {
1829 switch (prop) {
1830 case STMF_LU_PROP_ALIAS:
1831 case STMF_LU_PROP_SIZE:
1832 case STMF_LU_PROP_MGMT_URL:
1833 case STMF_LU_PROP_WRITE_PROTECT:
1834 case STMF_LU_PROP_WRITE_CACHE_DISABLE:
1835 case STMF_LU_PROP_UNMAP:
1836 return (STMF_STATUS_SUCCESS);
1837 break;
1838 default:
1839 return (STMF_STATUS_ERROR);
1840 break;
1841 }
1842 }
1843
1844 static int
1845 modifyDiskLu(diskResource *disk, stmfGuid *luGuid, const char *fname)
1846 {
1847 int ret = STMF_STATUS_SUCCESS;
1848 int luAliasLen = 0;
1849 int luMgmtUrlLen = 0;
1850 int mluBufSize = 0;
1851 int bufOffset = 0;
1852 int fd = 0;
1853 int ioctlRet;
1854 int savedErrno;
1855 int fnameSize = 0;
1900 sbdLu->mlu_alias_valid = 1;
1901 sbdLu->mlu_alias_off = bufOffset;
1902 bcopy(disk->luAlias, &(sbdLu->mlu_buf[bufOffset]),
1903 luAliasLen + 1);
1904 bufOffset += luAliasLen + 1;
1905 }
1906
1907 if (disk->luMgmtUrlValid) {
1908 sbdLu->mlu_mgmt_url_valid = 1;
1909 sbdLu->mlu_mgmt_url_off = bufOffset;
1910 bcopy(disk->luMgmtUrl, &(sbdLu->mlu_buf[bufOffset]),
1911 luMgmtUrlLen + 1);
1912 bufOffset += luMgmtUrlLen + 1;
1913 }
1914
1915 if (disk->luSizeValid) {
1916 sbdLu->mlu_lu_size_valid = 1;
1917 sbdLu->mlu_lu_size = disk->luSize;
1918 }
1919
1920 if (disk->unmapValid) {
1921 sbdLu->mlu_unmap_valid = 1;
1922 if (disk->unmap)
1923 sbdLu->mlu_unmap = 1;
1924 }
1925
1926 if (disk->writeProtectEnableValid) {
1927 sbdLu->mlu_write_protected_valid = 1;
1928 if (disk->writeProtectEnable) {
1929 sbdLu->mlu_write_protected = 1;
1930 }
1931 }
1932
1933 if (disk->writebackCacheDisableValid) {
1934 sbdLu->mlu_writeback_cache_disable_valid = 1;
1935 if (disk->writebackCacheDisable) {
1936 sbdLu->mlu_writeback_cache_disable = 1;
1937 }
1938 }
1939
1940 if (luGuid) {
1941 bcopy(luGuid, sbdLu->mlu_input_guid, sizeof (stmfGuid));
1942 sbdLu->mlu_by_guid = 1;
1943 } else {
1944 sbdLu->mlu_fname_off = bufOffset;
1945 bcopy(fname, &(sbdLu->mlu_buf[bufOffset]), fnameSize + 1);
2343 diskLu->luAliasValid = B_TRUE;
2344 if (strlcpy(diskLu->luAlias,
2345 (char *)&(sbdProps->slp_buf[
2346 sbdProps->slp_data_fname_off]),
2347 sizeof (diskLu->luAlias)) >=
2348 sizeof (diskLu->luAlias)) {
2349 return (STMF_STATUS_ERROR);
2350 }
2351 }
2352 }
2353
2354 diskLu->vidValid = B_TRUE;
2355 bcopy(sbdProps->slp_vid, diskLu->vid, sizeof (diskLu->vid));
2356
2357 diskLu->pidValid = B_TRUE;
2358 bcopy(sbdProps->slp_pid, diskLu->pid, sizeof (diskLu->pid));
2359
2360 diskLu->revValid = B_TRUE;
2361 bcopy(sbdProps->slp_rev, diskLu->rev, sizeof (diskLu->rev));
2362
2363 diskLu->unmapValid = B_TRUE;
2364 if (sbdProps->slp_unmap_cur)
2365 diskLu->unmap = B_TRUE;
2366
2367 diskLu->writeProtectEnableValid = B_TRUE;
2368 if (sbdProps->slp_write_protected) {
2369 diskLu->writeProtectEnable = B_TRUE;
2370 }
2371
2372 diskLu->writebackCacheDisableValid = B_TRUE;
2373 if (sbdProps->slp_writeback_cache_disable_cur) {
2374 diskLu->writebackCacheDisable = B_TRUE;
2375 }
2376
2377 diskLu->blkSizeValid = B_TRUE;
2378 diskLu->blkSize = sbdProps->slp_blksize;
2379
2380 diskLu->luSizeValid = B_TRUE;
2381 diskLu->luSize = sbdProps->slp_lu_size;
2382
2383 diskLu->accessState = sbdProps->slp_access_state;
2384
2385 return (ret);
2386 }
2821 propVal[sizeof (diskLu->pid)] = 0;
2822 break;
2823 case STMF_LU_PROP_WRITE_PROTECT:
2824 if (diskLu->writeProtectEnableValid == B_FALSE) {
2825 return (STMF_ERROR_NO_PROP);
2826 }
2827 if (diskLu->writeProtectEnable) {
2828 if ((reqLen = strlcpy(propVal, "true",
2829 *propLen)) >= *propLen) {
2830 *propLen = reqLen + 1;
2831 return (STMF_ERROR_INVALID_ARG);
2832 }
2833 } else {
2834 if ((reqLen = strlcpy(propVal, "false",
2835 *propLen)) >= *propLen) {
2836 *propLen = reqLen + 1;
2837 return (STMF_ERROR_INVALID_ARG);
2838 }
2839 }
2840 break;
2841 case STMF_LU_PROP_UNMAP:
2842 if (!diskLu->unmapValid)
2843 return (STMF_ERROR_NO_PROP);
2844 if (diskLu->unmap) {
2845 if ((reqLen = strlcpy(propVal, "true",
2846 *propLen)) >= *propLen) {
2847 *propLen = reqLen + 1;
2848 return (STMF_ERROR_INVALID_ARG);
2849 }
2850 } else {
2851 if ((reqLen = strlcpy(propVal, "false",
2852 *propLen)) >= *propLen) {
2853 *propLen = reqLen + 1;
2854 return (STMF_ERROR_INVALID_ARG);
2855 }
2856 }
2857 break;
2858 case STMF_LU_PROP_WRITE_CACHE_DISABLE:
2859 if (diskLu->writebackCacheDisableValid == B_FALSE) {
2860 return (STMF_ERROR_NO_PROP);
2861 }
2862 if (diskLu->writebackCacheDisable) {
2863 if ((reqLen = strlcpy(propVal, "true",
2864 *propLen)) >= *propLen) {
2865 *propLen = reqLen + 1;
2866 return (STMF_ERROR_INVALID_ARG);
2867 }
2868 } else {
2869 if ((reqLen = strlcpy(propVal, "false",
2870 *propLen)) >= *propLen) {
2871 *propLen = reqLen + 1;
2872 return (STMF_ERROR_INVALID_ARG);
2873 }
2874 }
2875 break;
2876 default:
2877 ret = STMF_ERROR_INVALID_PROP;
3057 case STMF_LU_PROP_WRITE_PROTECT:
3058 if (strcasecmp(propVal, "TRUE") == 0) {
3059 diskLu->writeProtectEnable = B_TRUE;
3060 } else if (strcasecmp(propVal, "FALSE") == 0) {
3061 diskLu->writeProtectEnable = B_FALSE;
3062 } else {
3063 return (STMF_ERROR_INVALID_ARG);
3064 }
3065 diskLu->writeProtectEnableValid = B_TRUE;
3066 break;
3067 case STMF_LU_PROP_WRITE_CACHE_DISABLE:
3068 if (strcasecmp(propVal, "TRUE") == 0) {
3069 diskLu->writebackCacheDisable = B_TRUE;
3070 } else if (strcasecmp(propVal, "FALSE") == 0) {
3071 diskLu->writebackCacheDisable = B_FALSE;
3072 } else {
3073 return (STMF_ERROR_INVALID_ARG);
3074 }
3075 diskLu->writebackCacheDisableValid = B_TRUE;
3076 break;
3077 case STMF_LU_PROP_UNMAP:
3078 if (strcasecmp(propVal, "TRUE") == 0) {
3079 diskLu->unmap = B_TRUE;
3080 } else if (strcasecmp(propVal, "FALSE") == 0) {
3081 diskLu->unmap = B_FALSE;
3082 } else {
3083 return (STMF_ERROR_INVALID_ARG);
3084 }
3085 diskLu->unmapValid = B_TRUE;
3086 break;
3087 case STMF_LU_PROP_ACCESS_STATE:
3088 ret = STMF_ERROR_INVALID_PROP;
3089 break;
3090 default:
3091 ret = STMF_ERROR_INVALID_PROP;
3092 break;
3093 }
3094 return (ret);
3095 }
3096
3097 static int
3098 checkHexUpper(char *buf)
3099 {
3100 int i;
3101
3102 for (i = 0; i < strlen(buf); i++) {
3103 if (isxdigit(buf[i])) {
3104 buf[i] = toupper(buf[i]);
3105 continue;
3106 }
|