RMDIR3res *nfsproc3_rmdir_3_svc(RMDIR3args * argp, struct svc_req * rqstp) { static RMDIR3res result; char *path; char obj[NFS_MAXPATHLEN]; int res; PREP(path, argp->object.dir); result.status = join(cat_name(path, argp->object.name, obj), exports_rw()); cluster_lookup(obj, rqstp, &result.status); if (result.status == NFS3_OK) { change_readdir_cookie(); res = backend_rmdir(obj); if (res == -1) result.status = rmdir_err(); } /* overlaps with resfail */ result.RMDIR3res_u.resok.dir_wcc.before = get_pre_cached(); result.RMDIR3res_u.resok.dir_wcc.after = get_post_stat(path, rqstp); return &result; }
RENAME3res *nfsproc3_rename_3_svc(RENAME3args * argp, struct svc_req * rqstp) { static RENAME3res result; char *from; char *to; char from_obj[NFS_MAXPATHLEN]; char to_obj[NFS_MAXPATHLEN]; pre_op_attr pre; post_op_attr post; int res; PREP(from, argp->from.dir); pre = get_pre_cached(); result.status = join(cat_name(from, argp->from.name, from_obj), exports_rw()); cluster_lookup(from_obj, rqstp, &result.status); to = fh_decomp(argp->to.dir); if (result.status == NFS3_OK) { result.status = join(cat_name(to, argp->to.name, to_obj), exports_compat(to, rqstp)); cluster_create(to_obj, rqstp, &result.status); if (result.status == NFS3_OK) { change_readdir_cookie(); res = backend_rename(from_obj, to_obj); if (res == -1) result.status = rename_err(); } } post = get_post_attr(from, argp->from.dir, rqstp); /* overlaps with resfail */ result.RENAME3res_u.resok.fromdir_wcc.before = pre; result.RENAME3res_u.resok.fromdir_wcc.after = post; result.RENAME3res_u.resok.todir_wcc.before = get_pre_cached(); result.RENAME3res_u.resok.todir_wcc.after = get_post_stat(to, rqstp); return &result; }
SYMLINK3res *nfsproc3_symlink_3_svc(SYMLINK3args * argp, struct svc_req * rqstp) { static SYMLINK3res result; char *path; pre_op_attr pre; post_op_attr post; char obj[NFS_MAXPATHLEN]; int res; mode_t new_mode; PREP(path, argp->where.dir); pre = get_pre_cached(); result.status = join3(cat_name(path, argp->where.name, obj), atomic_attr(argp->symlink.symlink_attributes), exports_rw()); cluster_create(obj, rqstp, &result.status); if (argp->symlink.symlink_attributes.mode.set_it == TRUE) new_mode = create_mode(argp->symlink.symlink_attributes); else { /* default rwxrwxrwx */ new_mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH; } if (result.status == NFS3_OK) { umask(~new_mode); res = backend_symlink(argp->symlink.symlink_data, obj); umask(0); if (res == -1) result.status = symlink_err(); else { result.SYMLINK3res_u.resok.obj = fh_extend_type(argp->where.dir, obj, S_IFLNK); result.SYMLINK3res_u.resok.obj_attributes = get_post_cached(rqstp); } } post = get_post_attr(path, argp->where.dir, rqstp); /* overlaps with resfail */ result.SYMLINK3res_u.resok.dir_wcc.before = pre; result.SYMLINK3res_u.resok.dir_wcc.after = post; return &result; }
LOOKUP3res *nfsproc3_lookup_3_svc(LOOKUP3args * argp, struct svc_req * rqstp) { static LOOKUP3res result; unfs3_fh_t *fh; char *path; char obj[NFS_MAXPATHLEN]; backend_statstruct buf; int res; uint32 gen; PREP(path, argp->what.dir); result.status = cat_name(path, argp->what.name, obj); cluster_lookup(obj, rqstp, &result.status); if (result.status == NFS3_OK) { res = backend_lstat(obj, &buf); if (res == -1) result.status = lookup_err(); else { if (strcmp(argp->what.name, ".") == 0 || strcmp(argp->what.name, "..") == 0) { fh = fh_comp_ptr(obj, rqstp, 0); } else { gen = backend_get_gen(buf, FD_NONE, obj); fh = fh_extend(argp->what.dir, buf.st_dev, buf.st_ino, gen); fh_cache_add(buf.st_dev, buf.st_ino, obj); } if (fh) { result.LOOKUP3res_u.resok.object.data.data_len = fh_length(fh); result.LOOKUP3res_u.resok.object.data.data_val = (char *) fh; result.LOOKUP3res_u.resok.obj_attributes = get_post_buf(buf, rqstp); } else { /* path was too long */ result.status = NFS3ERR_NAMETOOLONG; } } } /* overlaps with resfail */ result.LOOKUP3res_u.resok.dir_attributes = get_post_stat(path, rqstp); return &result; }
MKNOD3res *nfsproc3_mknod_3_svc(MKNOD3args * argp, struct svc_req * rqstp) { static MKNOD3res result; char *path; pre_op_attr pre; post_op_attr post; char obj[NFS_MAXPATHLEN]; int res; mode_t new_mode = 0; dev_t dev = 0; PREP(path, argp->where.dir); pre = get_pre_cached(); result.status = join3(cat_name(path, argp->where.name, obj), mknod_args(argp->what, obj, &new_mode, &dev), exports_rw()); cluster_create(obj, rqstp, &result.status); if (result.status == NFS3_OK) { if (argp->what.type == NF3CHR || argp->what.type == NF3BLK) res = backend_mknod(obj, new_mode, dev); /* device */ else if (argp->what.type == NF3FIFO) res = backend_mkfifo(obj, new_mode); /* FIFO */ else res = backend_mksocket(obj, new_mode); /* socket */ if (res == -1) { result.status = mknod_err(); } else { result.MKNOD3res_u.resok.obj = fh_extend_type(argp->where.dir, obj, type_to_mode(argp->what.type)); result.MKNOD3res_u.resok.obj_attributes = get_post_cached(rqstp); } } post = get_post_attr(path, argp->where.dir, rqstp); /* overlaps with resfail */ result.MKNOD3res_u.resok.dir_wcc.before = pre; result.MKNOD3res_u.resok.dir_wcc.after = post; return &result; }
w32_regex_traits_char_layer<charT>::w32_regex_traits_char_layer(::boost::re_detail::lcid_type l) : w32_regex_traits_base<charT>(l) { // we need to start by initialising our syntax map so we know which // character is used for which purpose: cat_type cat; std::string cat_name(w32_regex_traits<charT>::get_catalog_name()); if(cat_name.size()) { cat = ::boost::re_detail::w32_cat_open(cat_name); if(!cat) { std::string m("Unable to open message catalog: "); std::runtime_error err(m + cat_name); boost::re_detail::raise_runtime_error(err); } } // // if we have a valid catalog then load our messages: // if(cat) { for(regex_constants::syntax_type i = 1; i < regex_constants::syntax_max; ++i) { string_type mss = ::boost::re_detail::w32_cat_get(cat, this->m_locale, i, get_default_message(i)); for(typename string_type::size_type j = 0; j < mss.size(); ++j) { this->m_char_map[mss[j]] = i; } } } else { for(regex_constants::syntax_type i = 1; i < regex_constants::syntax_max; ++i) { const char* ptr = get_default_syntax(i); while(ptr && *ptr) { this->m_char_map[static_cast<charT>(*ptr)] = i; ++ptr; } } } }
LINK3res *nfsproc3_link_3_svc(LINK3args * argp, struct svc_req * rqstp) { static LINK3res result; char *path, *old; pre_op_attr pre; post_op_attr post; char obj[NFS_MAXPATHLEN]; int res; PREP(path, argp->link.dir); pre = get_pre_cached(); result.status = join(cat_name(path, argp->link.name, obj), exports_rw()); cluster_create(obj, rqstp, &result.status); old = fh_decomp(argp->file); if (old && result.status == NFS3_OK) { result.status = exports_compat(old, rqstp); if (result.status == NFS3_OK) { res = backend_link(old, obj); if (res == -1) result.status = link_err(); } } else if (!old) result.status = NFS3ERR_STALE; post = get_post_attr(path, argp->link.dir, rqstp); /* overlaps with resfail */ result.LINK3res_u.resok.file_attributes = get_post_stat(old, rqstp); result.LINK3res_u.resok.linkdir_wcc.before = pre; result.LINK3res_u.resok.linkdir_wcc.after = post; return &result; }
MKDIR3res *nfsproc3_mkdir_3_svc(MKDIR3args * argp, struct svc_req * rqstp) { static MKDIR3res result; char *path; pre_op_attr pre; post_op_attr post; char obj[NFS_MAXPATHLEN]; int res; PREP(path, argp->where.dir); pre = get_pre_cached(); result.status = join3(cat_name(path, argp->where.name, obj), atomic_attr(argp->attributes), exports_rw()); cluster_create(obj, rqstp, &result.status); if (result.status == NFS3_OK) { res = backend_mkdir(obj, create_mode(argp->attributes)); if (res == -1) result.status = mkdir_err(); else { result.MKDIR3res_u.resok.obj = fh_extend_type(argp->where.dir, obj, S_IFDIR); result.MKDIR3res_u.resok.obj_attributes = get_post_cached(rqstp); } } post = get_post_attr(path, argp->where.dir, rqstp); /* overlaps with resfail */ result.MKDIR3res_u.resok.dir_wcc.before = pre; result.MKDIR3res_u.resok.dir_wcc.after = post; return &result; }
/* Panic over an unhandled exception throw by category. */ static void panic_unhandled_cat(MVMThreadContext *tc, MVMuint32 cat) { fprintf(stderr, "No exception handler located for %s\n", cat_name(tc, cat)); dump_backtrace(tc); exit(1); }
void cpp_regex_traits_char_layer<charT>::init() { // we need to start by initialising our syntax map so we know which // character is used for which purpose: #ifndef BOOST_NO_STD_MESSAGES #ifndef __IBMCPP__ typename std::messages<charT>::catalog cat = static_cast<std::messages<char>::catalog>(-1); #else typename std::messages<charT>::catalog cat = reinterpret_cast<std::messages<char>::catalog>(-1); #endif std::string cat_name(cpp_regex_traits<charT>::get_catalog_name()); if(cat_name.size() && (this->m_pmessages != 0)) { cat = this->m_pmessages->open( cat_name, this->m_locale); if((int)cat < 0) { std::string m("Unable to open message catalog: "); std::runtime_error err(m + cat_name); boost::re_detail::raise_runtime_error(err); } } // // if we have a valid catalog then load our messages: // if((int)cat >= 0) { #ifndef BOOST_NO_EXCEPTIONS try{ #endif for(regex_constants::syntax_type i = 1; i < regex_constants::syntax_max; ++i) { string_type mss = this->m_pmessages->get(cat, 0, i, get_default_message(i)); for(typename string_type::size_type j = 0; j < mss.size(); ++j) { m_char_map[mss[j]] = i; } } this->m_pmessages->close(cat); #ifndef BOOST_NO_EXCEPTIONS } catch(...) { if(this->m_pmessages) this->m_pmessages->close(cat); throw; } #endif } else { #endif for(regex_constants::syntax_type i = 1; i < regex_constants::syntax_max; ++i) { const char* ptr = get_default_syntax(i); while(ptr && *ptr) { m_char_map[this->m_pctype->widen(*ptr)] = i; ++ptr; } } #ifndef BOOST_NO_STD_MESSAGES } #endif }
void cpp_regex_traits_char_layer<char>::init() { // we need to start by initialising our syntax map so we know which // character is used for which purpose: std::memset(m_char_map, 0, sizeof(m_char_map)); #ifndef BOOST_NO_STD_MESSAGES #ifndef __IBMCPP__ std::messages<char>::catalog cat = static_cast<std::messages<char>::catalog>(-1); #else std::messages<char>::catalog cat = reinterpret_cast<std::messages<char>::catalog>(-1); #endif std::string cat_name(cpp_regex_traits<char>::get_catalog_name()); if(cat_name.size() && (m_pmessages != 0)) { cat = this->m_pmessages->open( cat_name, this->m_locale); if((int)cat < 0) { std::string m("Unable to open message catalog: "); std::runtime_error err(m + cat_name); boost::re_detail::raise_runtime_error(err); } } // // if we have a valid catalog then load our messages: // if((int)cat >= 0) { #ifndef BOOST_NO_EXCEPTIONS try{ #endif for(regex_constants::syntax_type i = 1; i < regex_constants::syntax_max; ++i) { string_type mss = this->m_pmessages->get(cat, 0, i, get_default_syntax(i)); for(string_type::size_type j = 0; j < mss.size(); ++j) { m_char_map[static_cast<unsigned char>(mss[j])] = i; } } this->m_pmessages->close(cat); #ifndef BOOST_NO_EXCEPTIONS } catch(...) { this->m_pmessages->close(cat); throw; } #endif } else { #endif for(regex_constants::syntax_type j = 1; j < regex_constants::syntax_max; ++j) { const char* ptr = get_default_syntax(j); while(ptr && *ptr) { m_char_map[static_cast<unsigned char>(*ptr)] = j; ++ptr; } } #ifndef BOOST_NO_STD_MESSAGES } #endif // // finish off by calculating our escape types: // unsigned char i = 'A'; do { if(m_char_map[i] == 0) { if(this->m_pctype->is(std::ctype_base::lower, i)) m_char_map[i] = regex_constants::escape_type_class; else if(this->m_pctype->is(std::ctype_base::upper, i)) m_char_map[i] = regex_constants::escape_type_not_class; } }while(0xFF != i++); }
void w32_regex_traits_char_layer<char>::init() { // we need to start by initialising our syntax map so we know which // character is used for which purpose: std::memset(m_char_map, 0, sizeof(m_char_map)); cat_type cat; std::string cat_name(w32_regex_traits<char>::get_catalog_name()); if(cat_name.size()) { cat = ::pdalboost::BOOST_REGEX_DETAIL_NS::w32_cat_open(cat_name); if(!cat) { std::string m("Unable to open message catalog: "); std::runtime_error err(m + cat_name); ::pdalboost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(err); } } // // if we have a valid catalog then load our messages: // if(cat) { for(regex_constants::syntax_type i = 1; i < regex_constants::syntax_max; ++i) { string_type mss = ::pdalboost::BOOST_REGEX_DETAIL_NS::w32_cat_get(cat, this->m_locale, i, get_default_syntax(i)); for(string_type::size_type j = 0; j < mss.size(); ++j) { m_char_map[static_cast<unsigned char>(mss[j])] = i; } } } else { for(regex_constants::syntax_type i = 1; i < regex_constants::syntax_max; ++i) { const char* ptr = get_default_syntax(i); while(ptr && *ptr) { m_char_map[static_cast<unsigned char>(*ptr)] = i; ++ptr; } } } // // finish off by calculating our escape types: // unsigned char i = 'A'; do { if(m_char_map[i] == 0) { if(::pdalboost::BOOST_REGEX_DETAIL_NS::w32_is(this->m_locale, 0x0002u, (char)i)) m_char_map[i] = regex_constants::escape_type_class; else if(::pdalboost::BOOST_REGEX_DETAIL_NS::w32_is(this->m_locale, 0x0001u, (char)i)) m_char_map[i] = regex_constants::escape_type_not_class; } }while(0xFF != i++); // // fill in lower case map: // char char_map[1 << CHAR_BIT]; for(int ii = 0; ii < (1 << CHAR_BIT); ++ii) char_map[ii] = static_cast<char>(ii); #ifndef BOOST_NO_ANSI_APIS int r = ::LCMapStringA(this->m_locale, LCMAP_LOWERCASE, char_map, 1 << CHAR_BIT, this->m_lower_map, 1 << CHAR_BIT); BOOST_ASSERT(r != 0); #else UINT code_page = get_code_page_for_locale_id(this->m_locale); BOOST_ASSERT(code_page != 0); WCHAR wide_char_map[1 << CHAR_BIT]; int conv_r = ::MultiByteToWideChar(code_page, 0, char_map, 1 << CHAR_BIT, wide_char_map, 1 << CHAR_BIT); BOOST_ASSERT(conv_r != 0); WCHAR wide_lower_map[1 << CHAR_BIT]; int r = ::LCMapStringW(this->m_locale, LCMAP_LOWERCASE, wide_char_map, 1 << CHAR_BIT, wide_lower_map, 1 << CHAR_BIT); BOOST_ASSERT(r != 0); conv_r = ::WideCharToMultiByte(code_page, 0, wide_lower_map, r, this->m_lower_map, 1 << CHAR_BIT, NULL, NULL); BOOST_ASSERT(conv_r != 0); #endif if(r < (1 << CHAR_BIT)) { // if we have multibyte characters then not all may have been given // a lower case mapping: for(int jj = r; jj < (1 << CHAR_BIT); ++jj) this->m_lower_map[jj] = static_cast<char>(jj); } #ifndef BOOST_NO_ANSI_APIS r = ::GetStringTypeExA(this->m_locale, CT_CTYPE1, char_map, 1 << CHAR_BIT, this->m_type_map); #else r = ::GetStringTypeExW(this->m_locale, CT_CTYPE1, wide_char_map, 1 << CHAR_BIT, this->m_type_map); #endif BOOST_ASSERT(0 != r); }
CREATE3res *nfsproc3_create_3_svc(CREATE3args * argp, struct svc_req * rqstp) { static CREATE3res result; char *path; char obj[NFS_MAXPATHLEN]; sattr3 new_attr; int fd = -1, res = -1; backend_statstruct buf; uint32 gen; int flags = O_RDWR | O_CREAT | O_TRUNC | O_NONBLOCK; PREP(path, argp->where.dir); result.status = join(cat_name(path, argp->where.name, obj), exports_rw()); cluster_create(obj, rqstp, &result.status); /* GUARDED and EXCLUSIVE maps to Unix exclusive create */ if (argp->how.mode != UNCHECKED) flags = flags | O_EXCL; if (argp->how.mode != EXCLUSIVE) { new_attr = argp->how.createhow3_u.obj_attributes; result.status = join(result.status, atomic_attr(new_attr)); } /* Try to open the file */ if (result.status == NFS3_OK) { if (argp->how.mode != EXCLUSIVE) { fd = backend_open_create(obj, flags, create_mode(new_attr)); } else { fd = backend_open_create(obj, flags, create_mode(new_attr)); } } if (fd != -1) { /* Successful open */ res = backend_fstat(fd, &buf); if (res != -1) { /* Successful stat */ if (argp->how.mode == EXCLUSIVE) { /* Save verifier in atime and mtime */ res = backend_store_create_verifier(obj, argp->how.createhow3_u. verf); } } if (res != -1) { /* So far, so good */ gen = backend_get_gen(buf, fd, obj); fh_cache_add(buf.st_dev, buf.st_ino, obj); backend_close(fd); result.CREATE3res_u.resok.obj = fh_extend_post(argp->where.dir, buf.st_dev, buf.st_ino, gen); result.CREATE3res_u.resok.obj_attributes = get_post_buf(buf, rqstp); } if (res == -1) { /* backend_fstat() or backend_store_create_verifier() failed */ backend_close(fd); result.status = NFS3ERR_IO; } } else if (result.status == NFS3_OK) { /* open() failed */ if (argp->how.mode == EXCLUSIVE && errno == EEXIST) { /* Check if verifier matches */ fd = backend_open(obj, O_NONBLOCK); if (fd != -1) { res = backend_fstat(fd, &buf); } if (res != -1) { if (backend_check_create_verifier (&buf, argp->how.createhow3_u.verf)) { /* The verifier matched. Return success */ gen = backend_get_gen(buf, fd, obj); fh_cache_add(buf.st_dev, buf.st_ino, obj); backend_close(fd); result.CREATE3res_u.resok.obj = fh_extend_post(argp->where.dir, buf.st_dev, buf.st_ino, gen); result.CREATE3res_u.resok.obj_attributes = get_post_buf(buf, rqstp); } else { /* The verifier doesn't match */ result.status = NFS3ERR_EXIST; } } } if (res == -1) { result.status = create_err(); } } /* overlaps with resfail */ result.CREATE3res_u.resok.dir_wcc.before = get_pre_cached(); result.CREATE3res_u.resok.dir_wcc.after = get_post_stat(path, rqstp); return &result; }