bool error(std::string *error=nullptr) const { if (getErrno()) { if (error) { *error = str(boost::format("%1%: %2%") % path_ % std::system_category().message(getErrno())); } return true; } return false; }
int _ifuseFileCacheRead( fileCache_t *fileCache, char *buf, size_t size, off_t offset ) { int status, myError; status = _iFuseFileCacheLseek( fileCache, offset ); if ( status < 0 ) { if ( ( myError = getErrno( status ) ) > 0 ) { return -myError; } else { return -ENOENT; } } if ( fileCache->state == NO_FILE_CACHE ) { iFuseConn_t *conn; openedDataObjInp_t dataObjReadInp; bytesBuf_t dataObjReadOutBBuf; int myError; bzero( &dataObjReadInp, sizeof( dataObjReadInp ) ); dataObjReadOutBBuf.buf = buf; dataObjReadOutBBuf.len = size; dataObjReadInp.l1descInx = fileCache->iFd; dataObjReadInp.len = size; //UNLOCK_STRUCT(*fileCache); conn = getAndUseConnByPath( fileCache->localPath, &status ); //LOCK_STRUCT(*fileCache); status = rcDataObjRead( conn->conn, &dataObjReadInp, &dataObjReadOutBBuf ); unuseIFuseConn( conn ); if ( status < 0 ) { if ( ( myError = getErrno( status ) ) > 0 ) { return -myError; } else { return -ENOENT; } } } else { status = read( fileCache->iFd, buf, size ); if ( status < 0 ) { return errno ? ( -1 * errno ) : -1; } } fileCache->offset += status; return status; }
void BasicUsageEnvironment0::setResultErrMsg(MsgString msg, int err) { setResultMsg(msg); #ifndef _WIN32_WCE appendToResultMsg(strerror(err == 0 ? getErrno() : err)); #endif }
// =-=-=-=-=-=-=- // local function to handle call to mkdir via resource plugin int _rsFileMkdir( rsComm_t* _comm, fileMkdirInp_t* _mkdir_inp ) { // =-=-=-=-=-=-=- // make call to mkdir via resource plugin irods::collection_object_ptr coll_obj( new irods::collection_object( _mkdir_inp->dirName, _mkdir_inp->rescHier, _mkdir_inp->mode, 0 ) ); // =-=-=-=-=-=-=- // pass condInput coll_obj->cond_input( _mkdir_inp->condInput ); irods::error mkdir_err = fileMkdir( _comm, coll_obj ); // =-=-=-=-=-=-=- // log error if necessary if ( !mkdir_err.ok() ) { if ( getErrno( mkdir_err.code() ) != EEXIST ) { std::stringstream msg; msg << "fileMkdir failed for "; msg << _mkdir_inp->dirName; msg << "]"; irods::error ret_err = PASSMSG( msg.str(), mkdir_err ); irods::log( ret_err ); } } return ( mkdir_err.code() ); } // _rsFileMkdir
int irodsRelease (const char *path, struct fuse_file_info *fi) { int descInx; int status, myError; rodsLog (LOG_DEBUG, "irodsRelease: %s", path); descInx = fi->fh; /* if (checkFuseDesc (descInx) < 0) { return -EBADF; } */ status = ifuseClose (&IFuseDesc[descInx]); if (status < 0) { if ((myError = getErrno (status)) > 0) { return (-myError); } else { return -ENOENT; } } else { return (0); } }
QByteArray GetBlobResponseJSON::getJson() const { QJson::Serializer serializer; QVariantMap obj; obj["errno"] = getErrno(); obj.insert("blob", m_blob); return serializer.serialize(obj); }
QByteArray VersionResponseJSON::getJson() const { QJson::Serializer serializer; QVariantMap obj; obj.insert("errno", m_errno); if (getErrno()== SUCCESS) obj.insert("version", m_version); return serializer.serialize(obj); }
int convZoneSockError( int inStatus ) { int unixErr = getErrno( inStatus ); if ( inStatus + unixErr == USER_SOCK_CONNECT_ERR ) { return CROSS_ZONE_SOCK_CONNECT_ERR - unixErr; } else { return inStatus; } }
World OMstatus OMbindUnix(OMconn conn, char *file) { OMdev indev, outdev; int nsd, ansd; int dummy; struct sockaddr_un nad; struct sockaddr_un target; winInit(); nsd = socket(AF_UNIX, SOCK_STREAM, 0); if (nsd < 0) { conn->error = OMerrorSys; return OMfailed; } /* fill the address */ ZERO(nad); nad.sun_family = AF_UNIX; strcpy(nad.sun_path, file); /* bind "nsd" at the UNIX-domain address. "+2" seems necessary... */ if (bind(nsd, (struct sockaddr *) &nad, strlen(nad.sun_path) + 2) != 0) { if (getErrno() == EADDRINUSE) { conn->error = OMaddrInUse; return OMaddrInUse; } else { conn->error = OMerrorSys; return OMfailed; } } listen(nsd, 1); /* now, we can accept */ dummy = sizeof(target); ansd = accept(nsd, (struct sockaddr *) &target, &dummy); if (ansd < 0) { conn->error = OMerrorSys; return OMfailed; } /* don't need it anymore */ close(nsd); indev = OMmakeDevice(DEFAULT_ENCODING, OMmakeIOFd(ansd)); outdev = OMmakeDevice(DEFAULT_ENCODING, OMmakeIOFd(ansd)); conn->in = indev; conn->out = outdev; return OMsuccess; }
static int irods_reli_errno( int e ) { int unix_errno; if(e==CAT_NO_ROWS_FOUND) { unix_errno = ENOENT; } else { unix_errno = getErrno(e); if(unix_errno>32) { debug(D_NOTICE,"irods returned unexpected error code %d",e); unix_errno = EIO; } } return unix_errno; }
void BasicUsageEnvironment0::setResultErrMsg(MsgString msg, int err) { setResultMsg(msg); if (err == 0) err = getErrno(); #if defined(__WIN32__) || defined(_WIN32) || defined(_WIN32_WCE) char errMsg[RESULT_MSG_BUFFER_MAX] = "\0"; if (0 != FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0, errMsg, sizeof(errMsg)/sizeof(errMsg[0]), NULL)) { // Remove all trailing '\r', '\n' and '.' for (char* p = errMsg + strlen(errMsg); p != errMsg && (*p == '\r' || *p == '\n' || *p == '.' || *p == '\0'); --p) { *p = '\0'; } } else snprintf(errMsg, sizeof(errMsg)/sizeof(errMsg[0]), "error %d", err); appendToResultMsg(errMsg); #else appendToResultMsg(strerror(err)); #endif }
int _rsFileMkdir (rsComm_t *rsComm, fileMkdirInp_t *fileMkdirInp) { int status; status = fileMkdir (fileMkdirInp->fileType, rsComm, fileMkdirInp->dirName, fileMkdirInp->mode, &fileMkdirInp->condInput); if (status < 0) { if (getErrno (status) != EEXIST) rodsLog (LOG_NOTICE, "_rsFileMkdir: fileMkdir for %s, status = %d", fileMkdirInp->dirName, status); return (status); } return (status); }
World OMstatus OMbindTCP(OMconn conn, int port) { OMdev indev, outdev; int nsd, ansd, dummy; struct sockaddr_in nad; struct sockaddr_un target; winInit(); nsd = socket(AF_INET, SOCK_STREAM, 0); ZERO(nad); nad.sin_family = AF_INET; nad.sin_addr.s_addr = INADDR_ANY; nad.sin_port = htons((unsigned short) port); if (bind(nsd, (struct sockaddr *) &nad, sizeof nad) != 0) { close(nsd); if (getErrno() == EADDRINUSE) { conn->error = OMaddrInUse; return OMaddrInUse; } else { conn->error = OMerrorSys; return OMfailed; } } listen(nsd, 1); dummy = sizeof(target); ansd = accept(nsd, (struct sockaddr *) &target, &dummy); close(nsd); indev = OMmakeDevice(DEFAULT_ENCODING, OMmakeIOFd(ansd)); outdev = OMmakeDevice(DEFAULT_ENCODING, OMmakeIOFd(ansd)); conn->in = indev; conn->out = outdev; return OMsuccess; }
QByteArray FilterDefaultResponseJSON::getJson() const { QJson::Serializer serializer; QVariantMap obj; QList<QSharedPointer<Channel> > hashKeys = m_hashMap.uniqueKeys(); QVariantList jchannels; for(int i=0; i<hashKeys.size(); i++) { QList<QSharedPointer<DataMark> > tags = m_hashMap.values(hashKeys.at(i)); QVariantList jtags; QVariantMap jchannel; QVariantMap channel; for(int j=0; j<tags.size(); j++) { QSharedPointer<DataMark> tag = tags.at(j); QVariantMap jtag; jtag["id"] = tag->getId(); jtag["title"] = tag->getLabel(); jtag["link"] = tag->getUrl(); jtag["description"] = tag->getDescription(); jtag["latitude"] = tag->getLatitude(); jtag["longitude"] = tag->getLongitude(); jtag["altitude"] = tag->getAltitude(); jtag["user"] = tag->getUser()->getLogin(); jtag["pubDate"] = tag->getTime().toString("dd MM yyyy HH:mm:ss.zzz"); jtags.append(jtag); } channel["items"] = jtags; channel["name"] = hashKeys.at(i)->getName(); jchannel["channel"] = channel; jchannels.append(jchannel); } obj["channels"] = jchannels; obj.insert("errno", getErrno()); return serializer.serialize(obj); }
int l3FilePutSingleBuf( rsComm_t *rsComm, int l1descInx, bytesBuf_t *dataObjInpBBuf ) { dataObjInfo_t *dataObjInfo; fileOpenInp_t filePutInp; int bytesWritten; dataObjInp_t *dataObjInp; int retryCnt = 0; int chkType = 0; // JMC - backport 4774 dataObjInfo = L1desc[l1descInx].dataObjInfo; dataObjInp = L1desc[l1descInx].dataObjInp; // =-=-=-=-=-=-=- // extract the host location from the resource hierarchy std::string location; irods::error ret = irods::get_loc_for_hier_string( dataObjInfo->rescHier, location ); if ( !ret.ok() ) { irods::log( PASSMSG( "l3FilePutSingleBuf - failed in get_loc_for_hier_string", ret ) ); return -1; } if ( getStructFileType( dataObjInfo->specColl ) >= 0 ) { subFile_t subFile; memset( &subFile, 0, sizeof( subFile ) ); rstrcpy( subFile.subFilePath, dataObjInfo->subPath, MAX_NAME_LEN ); rstrcpy( subFile.addr.hostAddr, location.c_str(), NAME_LEN ); subFile.specColl = dataObjInfo->specColl; subFile.mode = getFileMode( dataObjInp ); subFile.flags = O_WRONLY | dataObjInp->openFlags; if ( ( L1desc[l1descInx].replStatus & OPEN_EXISTING_COPY ) != 0 ) { subFile.flags |= FORCE_FLAG; } bytesWritten = rsSubStructFilePut( rsComm, &subFile, dataObjInpBBuf ); return bytesWritten; } // struct file type >= 0 std::string prev_resc_hier; memset( &filePutInp, 0, sizeof( filePutInp ) ); rstrcpy( filePutInp.resc_hier_, dataObjInfo->rescHier, MAX_NAME_LEN ); rstrcpy( filePutInp.objPath, dataObjInp->objPath, MAX_NAME_LEN ); if ( ( L1desc[l1descInx].replStatus & OPEN_EXISTING_COPY ) != 0 ) { filePutInp.otherFlags |= FORCE_FLAG; } rstrcpy( filePutInp.addr.hostAddr, location.c_str(), NAME_LEN ); rstrcpy( filePutInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN ); filePutInp.mode = getFileMode( dataObjInp ); filePutInp.flags = O_WRONLY | dataObjInp->openFlags; rstrcpy( filePutInp.in_pdmo, L1desc[l1descInx].in_pdmo, MAX_NAME_LEN ); // kv pasthru copyKeyVal( &dataObjInfo->condInput, &filePutInp.condInput ); // =-=-=-=-=-=-=- // JMC - backport 4774 chkType = getchkPathPerm( rsComm, L1desc[l1descInx].dataObjInp, L1desc[l1descInx].dataObjInfo ); if ( chkType == DISALLOW_PATH_REG ) { clearKeyVal( &filePutInp.condInput ); return PATH_REG_NOT_ALLOWED; } else if ( chkType == NO_CHK_PATH_PERM ) { // =-=-=-=-=-=-=- filePutInp.otherFlags |= NO_CHK_PERM_FLAG; // JMC - backport 4758 } filePutOut_t* put_out = 0; prev_resc_hier = filePutInp.resc_hier_; bytesWritten = rsFilePut( rsComm, &filePutInp, dataObjInpBBuf, &put_out ); // update the dataObjInfo with the potential changes made by the resource - hcj rstrcpy( dataObjInfo->rescHier, filePutInp.resc_hier_, MAX_NAME_LEN ); if ( put_out ) { rstrcpy( dataObjInfo->filePath, put_out->file_name, MAX_NAME_LEN ); free( put_out ); } /* file already exists ? */ while ( bytesWritten < 0 && retryCnt < 10 && ( filePutInp.otherFlags & FORCE_FLAG ) == 0 && getErrno( bytesWritten ) == EEXIST ) { if ( resolveDupFilePath( rsComm, dataObjInfo, dataObjInp ) < 0 ) { break; } rstrcpy( filePutInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN ); filePutOut_t* put_out = 0; bytesWritten = rsFilePut( rsComm, &filePutInp, dataObjInpBBuf, &put_out ); // update the dataObjInfo with the potential changes made by the resource - hcj rstrcpy( dataObjInfo->rescHier, filePutInp.resc_hier_, MAX_NAME_LEN ); if ( put_out ) { rstrcpy( dataObjInfo->filePath, put_out->file_name, MAX_NAME_LEN ); free( put_out ); } retryCnt ++; } // while clearKeyVal( &filePutInp.condInput ); return bytesWritten; } // l3FilePutSingleBuf
int mkFileDirR (int fileType, rsComm_t *rsComm, char *startDir, char *destDir, int mode) { int status; int startLen; int pathLen, tmpLen; char tmpPath[MAX_NAME_LEN]; struct stat statbuf; #ifdef DIRECT_ACCESS_VAULT rodsHostAddr_t addr; rodsServerHost_t *rodsServerHost; char *zoneName; char *outVaultPath; int vp_len; char collName[MAX_NAME_LEN]; keyValPair_t condInput; #endif startLen = strlen (startDir); pathLen = strlen (destDir); rstrcpy (tmpPath, destDir, MAX_NAME_LEN); tmpLen = pathLen; while (tmpLen > startLen) { status = fileStat ( (fileDriverType_t)fileType, rsComm, tmpPath, &statbuf); if (status >= 0) { if (statbuf.st_mode & S_IFDIR) { break; } else { rodsLog (LOG_NOTICE, "mkFileDirR: A local non-directory %s already exists \n", tmpPath); return (status); } } /* Go backward */ while (tmpLen && tmpPath[tmpLen] != '/') tmpLen --; tmpPath[tmpLen] = '\0'; } #ifdef DIRECT_ACCESS_VAULT if (fileType == DIRECT_ACCESS_FILE_TYPE) { zoneName = getLocalZoneName(); addr.hostAddr[0] = '\0'; resolveHost(&addr, &rodsServerHost); vp_len = matchVaultPath(rsComm, destDir, rodsServerHost, &outVaultPath); if (vp_len == 0) { outVaultPath = NULL; } } #endif /* Now we go forward and make the required dir */ while (tmpLen < pathLen) { /* Put back the '/' */ tmpPath[tmpLen] = '/'; #ifdef DIRECT_ACCESS_VAULT memset(&condInput, 0, sizeof(condInput)); if (fileType == DIRECT_ACCESS_FILE_TYPE) { snprintf(collName, MAX_NAME_LEN, "/%s%s", zoneName, tmpPath + vp_len); status = rsQueryDirectoryMeta(rsComm, collName, &condInput); } status = fileMkdir ((fileDriverType_t)fileType, rsComm, tmpPath, mode, &condInput); #else status = fileMkdir ((fileDriverType_t)fileType, rsComm, tmpPath, mode, NULL); #endif if (status < 0 && (getErrno (status) != EEXIST)) { rodsLog (LOG_NOTICE, "mkFileDirR: mkdir failed for %s, status =%d", tmpPath, status); return status; } #if 0 /* a fix from AndyS */ while (tmpLen && tmpPath[tmpLen] != '\0') #endif while (tmpPath[tmpLen] != '\0') tmpLen ++; } return 0; }
// =-=-=-=-=-=-=- // mk the directory recursively int mkFileDirR( rsComm_t * rsComm, size_t startDirLen, const std::string& destDir, const std::string& hier, int mode ) { std::string physical_directory_prefix; if ( destDir.empty() ) { rodsLog( LOG_ERROR, "mkFileDirR called with empty dest directory" ); return SYS_INVALID_INPUT_PARAM ; } if ( destDir.size() < startDirLen ) { rodsLog( LOG_ERROR, "mkFileDirR called with a destDir: [%s]" "shorter than its startDirLen: [%ju]", destDir.c_str(), ( uintmax_t )startDirLen ); return SYS_INVALID_INPUT_PARAM; } if ( !rsComm ) { rodsLog( LOG_ERROR, "mkFileDirR called with null rsComm" ); return SYS_INVALID_INPUT_PARAM; } if ( isValidFilePath( destDir ) ) { std::string vault_path; irods::error err = irods::get_vault_path_for_hier_string( hier, vault_path ); if ( !err.ok() ) { rodsLog( LOG_ERROR, err.result().c_str() ); return err.code(); } if ( destDir.compare( 0, vault_path.size(), vault_path ) == 0 && ( destDir[ vault_path.size() ] == '/' || destDir.size() == vault_path.size() ) ) { physical_directory_prefix = vault_path; } } std::vector< std::string > directories_to_create; std::string physical_directory = destDir; if ( physical_directory[ physical_directory.size() - 1 ] == '/' ) { physical_directory.erase( physical_directory.size() - 1 ); } while ( physical_directory.size() > startDirLen ) { irods::collection_object_ptr tmp_coll_obj( new irods::collection_object( physical_directory, hier, 0, 0 ) ); struct stat statbuf; irods::error stat_err = fileStat( rsComm, tmp_coll_obj, &statbuf ); if ( stat_err.code() >= 0 ) { if ( statbuf.st_mode & S_IFDIR ) { break; } else { rodsLog( LOG_NOTICE, "mkFileDirR: A local non-directory %s already exists \n", physical_directory.c_str() ); return stat_err.code(); } } else { directories_to_create.push_back( physical_directory.substr( physical_directory_prefix.size() ) ); } /* Go backward */ size_t index_of_last_slash = physical_directory.rfind( '/', physical_directory.size() - 1 ); if ( std::string::npos != index_of_last_slash ) { physical_directory = physical_directory.substr( 0, index_of_last_slash ); } else { break; } } // while std::string irods_directory_prefix = "/"; irods_directory_prefix += getLocalZoneName(); /* Now we go forward and make the required dir */ while ( !directories_to_create.empty() ) { physical_directory = physical_directory_prefix; physical_directory += directories_to_create.back(); std::string irods_directory = irods_directory_prefix; irods_directory += directories_to_create.back(); directories_to_create.pop_back(); irods::collection_object_ptr tmp_coll_obj( new irods::collection_object( physical_directory, hier, mode, 0 ) ); irods::error mkdir_err = fileMkdir( rsComm, tmp_coll_obj ); if ( !mkdir_err.ok() && ( getErrno( mkdir_err.code() ) != EEXIST ) ) { // JMC - backport 4834 std::stringstream msg; msg << "fileMkdir for ["; msg << physical_directory; msg << "]"; irods::error ret_err = PASSMSG( msg.str(), mkdir_err ); irods::log( ret_err ); return mkdir_err.code(); } } return 0; }
/* If any TCP sockets select true for writing, write out queued data * we have for them. */ static void write_tcp_data_core(ares_channel channel, int server_idx, time_t now) { struct server_state *server; struct send_request *sendreq; #ifdef WIN32 WSABUF *vec; #else struct iovec *vec; #endif int n, count; server = &channel->servers[server_idx]; if (!server->qhead || server->tcp_socket == -1 ) return; /* Count the number of send queue items. */ n = 0; for (sendreq = server->qhead; sendreq; sendreq = sendreq->next) n++; #ifdef WIN32 /* Allocate iovecs so we can send all our data at once. */ vec = malloc(n * sizeof(WSABUF)); if (vec) { int err; /* Fill in the iovecs and send. */ n = 0; for (sendreq = server->qhead; sendreq; sendreq = sendreq->next) { vec[n].buf = (char *) sendreq->data; vec[n].len = sendreq->len; n++; } err = WSASend(server->tcp_socket, vec, n, &count,0,0,0 ); if ( err == SOCKET_ERROR ) { count =-1; } free(vec); #else /* Allocate iovecs so we can send all our data at once. */ vec = malloc(n * sizeof(struct iovec)); if (vec) { // int err; /* Fill in the iovecs and send. */ n = 0; for (sendreq = server->qhead; sendreq; sendreq = sendreq->next) { vec[n].iov_base = (char *) sendreq->data; vec[n].iov_len = sendreq->len; n++; } count = writev(server->tcp_socket, vec, n); free(vec); #endif if (count < 0) { handle_error(channel, server_idx, now); return; } /* Advance the send queue by as many bytes as we sent. */ while (count) { sendreq = server->qhead; if (count >= sendreq->len) { count -= sendreq->len; server->qhead = sendreq->next; free(sendreq); if (server->qhead == NULL) { server->qtail = NULL; assert(count==0); break; } } else { sendreq->data += count; sendreq->len -= count; break; } } } else { /* Can't allocate iovecs; just send the first request. */ sendreq = server->qhead; #ifndef UNDER_CE count = write(server->tcp_socket, sendreq->data, sendreq->len); #else count = send(server->tcp_socket, sendreq->data, sendreq->len,0); #endif if (count < 0) { handle_error(channel, server_idx, now); return; } /* Advance the send queue by as many bytes as we sent. */ if (count == sendreq->len) { server->qhead = sendreq->next; if (server->qhead == NULL) server->qtail = NULL; free(sendreq); } else { sendreq->data += count; sendreq->len -= count; } } if ( server->qhead==NULL && channel->poll_cb_func ) { (*(channel->poll_cb_func))( channel->poll_cb_data, channel, server_idx, server->tcp_socket, ARES_POLLACTION_WRITEOFF); } } static void write_tcp_data(ares_channel channel, fd_set *write_fds, time_t now) { struct server_state *server; int i; for (i = 0; i < channel->nservers; i++) { /* Make sure server has data to send and is selected in write_fds. */ server = &channel->servers[i]; if (!server->qhead || server->tcp_socket == -1 ) continue; if ( write_fds && !FD_ISSET(server->tcp_socket, write_fds)) continue; write_tcp_data_core(channel, i, now); } } /* If any TCP socket selects true for reading, read some data, * allocate a buffer if we finish reading the length word, and process * a packet if we finish reading one. */ static void read_tcp_data(ares_channel channel, int server_idx, fd_set *read_fds, time_t now) { struct server_state *server; int i, count; for (i = 0; i < channel->nservers; i++) { /* Make sure the server has a socket and is selected in read_fds. */ if ( server_idx>=0 && i != server_idx ) continue; server = &channel->servers[i]; if (server->tcp_socket == -1 ) continue; if (!FD_ISSET(server->tcp_socket, read_fds)) continue; if (server->tcp_lenbuf_pos != 2) { /* We haven't yet read a length word, so read that (or * what's left to read of it). */ #if defined UNDER_CE || defined WIN32 count = recv(server->tcp_socket, server->tcp_lenbuf + server->tcp_lenbuf_pos, 2 - server->tcp_lenbuf_pos,0); #else count = read(server->tcp_socket, server->tcp_lenbuf + server->tcp_lenbuf_pos, 2 - server->tcp_lenbuf_pos); #endif if (count <= 0) { handle_error(channel, i, now); continue; } server->tcp_lenbuf_pos += count; if (server->tcp_lenbuf_pos == 2) { /* We finished reading the length word. Decode the * length and allocate a buffer for the data. */ server->tcp_length = server->tcp_lenbuf[0] << 8 | server->tcp_lenbuf[1]; server->tcp_buffer = malloc(server->tcp_length); if (!server->tcp_buffer) handle_error(channel, i, now); server->tcp_buffer_pos = 0; } } else { /* Read data into the allocated buffer. */ #if defined UNDER_CE || defined WIN32 count = recv(server->tcp_socket, server->tcp_buffer + server->tcp_buffer_pos, server->tcp_length - server->tcp_buffer_pos,0); #else count = read(server->tcp_socket, server->tcp_buffer + server->tcp_buffer_pos, server->tcp_length - server->tcp_buffer_pos); #endif if (count <= 0) { handle_error(channel, i, now); continue; } server->tcp_buffer_pos += count; if (server->tcp_buffer_pos == server->tcp_length) { /* We finished reading this answer; process it and * prepare to read another length word. */ process_answer(channel, server->tcp_buffer, server->tcp_length, i, 1, now); free(server->tcp_buffer); server->tcp_buffer = NULL; server->tcp_lenbuf_pos = 0; } } } } /* If any UDP sockets select true for reading, process them. */ static void read_udp_packets(ares_channel channel, int server_idx, fd_set *read_fds, time_t now) { struct server_state *server; int i, count; unsigned char buf[PACKETSZ + 1]; for (i = 0; i < channel->nservers; i++) { if ( server_idx>=0 && i != server_idx ) continue; /* Make sure the server has a socket and is selected in read_fds. */ server = &channel->servers[i]; if ( (server->udp_socket == -1) ) continue; if ( read_fds && !FD_ISSET(server->udp_socket, read_fds) ) continue; assert( server->udp_socket != -1 ); count = recv(server->udp_socket, buf, sizeof(buf), 0); if (count <= 0) { #if defined(WIN32) //int err; //err = WSAGetLastError(); //err = errno; switch (getErrno()) { case WSAEWOULDBLOCK: if ( read_fds ) { // read_fds is only null when using epoll // which shouldn't happen under windows // don't know why CLR is here anyways FD_CLR(server->udp_socket, read_fds); } continue; case WSAECONNABORTED: break; case WSAECONNRESET: // got an ICMP error on a previous send break; } #endif handle_error(channel, i, now); } else { process_answer(channel, buf, count, i, 0, now); } } } /* If any queries have timed out, note the timeout and move them on. */ static void process_timeouts(ares_channel channel, time_t now) { struct query *query, *next; for (query = channel->queries; query; query = next) { next = query->next; if (query->timeout != 0 && now >= query->timeout) { //fprintf(stderr, "kennard:ares:process_timeouts: got timeout\n"); query->error_status = ARES_ETIMEOUT; next_server(channel, query, now); } } } /* Handle an answer from a server. */ static void process_answer(ares_channel channel, unsigned char *abuf, int alen, int whichserver, int tcp, time_t now) { int id, tc, rcode; struct query *query; /* If there's no room in the answer for a header, we can't do much * with it. */ if (alen < HFIXEDSZ) return; /* Grab the query ID, truncate bit, and response code from the packet. */ id = DNS_HEADER_QID(abuf); tc = DNS_HEADER_TC(abuf); rcode = DNS_HEADER_RCODE(abuf); /* Find the query corresponding to this packet. */ for (query = channel->queries; query; query = query->next) { if (query->qid == id) break; } if (!query) return; /* If we got a truncated UDP packet and are not ignoring truncation, * don't accept the packet, and switch the query to TCP if we hadn't * done so already. */ if ((tc || alen > PACKETSZ) && !tcp && !(channel->flags & ARES_FLAG_IGNTC)) { if (!query->using_tcp) { query->using_tcp = 1; ares__send_query(channel, query, now); } return; } /* Limit alen to PACKETSZ if we aren't using TCP (only relevant if we * are ignoring truncation. */ if (alen > PACKETSZ && !tcp) alen = PACKETSZ; /* If we aren't passing through all error packets, discard packets * with SERVFAIL, NOTIMP, or REFUSED response codes. */ if (!(channel->flags & ARES_FLAG_NOCHECKRESP)) { if (rcode == SERVFAIL || rcode == NOTIMP || rcode == REFUSED) { query->skip_server[whichserver] = 1; if (query->server == whichserver) next_server(channel, query, now); return; } if (!same_questions((unsigned char*)query->qbuf, query->qlen, abuf, alen)) { if (query->server == whichserver) next_server(channel, query, now); return; } /* 'No such name' */ if ((channel->flags & ARES_FLAG_TRY_NEXT_SERVER_ON_RCODE3) && rcode == NXDOMAIN) { if (query->server == whichserver) { if (next_server_new_network(channel, query, now)) return; } } } end_query(channel, query, ARES_SUCCESS, abuf, alen); }
int _ifuseFileCacheWrite( fileCache_t *fileCache, char *buf, size_t size, off_t offset ) { int status, myError; openedDataObjInp_t dataObjWriteInp; bytesBuf_t dataObjWriteInpBBuf; iFuseConn_t *conn; bzero( &dataObjWriteInp, sizeof( dataObjWriteInp ) ); /* lseek to the right offset in case this cache is share by multiple descs */ status = _iFuseFileCacheLseek( fileCache, offset ); if ( status < 0 ) { if ( ( myError = getErrno( status ) ) > 0 ) { return -myError; } else { return -ENOENT; } } if ( fileCache->state == NO_FILE_CACHE ) { /* no file cache */ dataObjWriteInpBBuf.buf = ( void * ) buf; dataObjWriteInpBBuf.len = size; dataObjWriteInp.l1descInx = fileCache->iFd; dataObjWriteInp.len = size; conn = getAndUseConnByPath( fileCache->localPath, &status ); status = rcDataObjWrite( conn->conn, &dataObjWriteInp, &dataObjWriteInpBBuf ); unuseIFuseConn( conn ); if ( status < 0 ) { if ( ( myError = getErrno( status ) ) > 0 ) { return -myError; } else { return -ENOENT; } } else if ( status != ( int ) size ) { rodsLog( LOG_ERROR, "ifuseWrite: IFuseDesc[descInx].conn for %s is NULL", fileCache->localPath ); return -ENOENT; } fileCache->offset += status; if ( fileCache->offset > fileCache->fileSize ) { fileCache->fileSize = fileCache->offset; } } else { status = write( fileCache->iFd, buf, size ); if ( status < 0 ) { return errno ? ( -1 * errno ) : -1; } fileCache->offset += status; if ( fileCache->offset > fileCache->fileSize ) { fileCache->fileSize = fileCache->offset; } if ( fileCache->offset >= MAX_NEWLY_CREATED_CACHE_SIZE ) { _iFuseFileCacheFlush( fileCache ); fileCache->iFd = 0; /* reopen file */ dataObjInp_t dataObjOpenInp; memset( &dataObjOpenInp, 0, sizeof( dataObjOpenInp ) ); rstrcpy( dataObjOpenInp.objPath, fileCache->objPath, MAX_NAME_LEN ); dataObjOpenInp.openFlags = O_RDWR; int status; conn = getAndUseConnByPath( fileCache->localPath, &status ); status = rcDataObjOpen( conn->conn, &dataObjOpenInp ); unuseIFuseConn( conn ); if ( status < 0 ) { rodsLog( LOG_ERROR, "iFuseWrite: rcDataObjOpen of %s error. status = %d", fileCache->objPath, status ); return -ENOENT; } fileCache->iFd = status; } } return status; }
int l3CreateByObjInfo( rsComm_t *rsComm, dataObjInp_t *dataObjInp, dataObjInfo_t *dataObjInfo ) { int l3descInx; int retryCnt = 0; int chkType = 0; // JMC - backport 4774 // =-=-=-=-=-=-=- // extract the host location from the resource hierarchy std::string location; irods::error ret = irods::get_loc_for_hier_string( dataObjInfo->rescHier, location ); if ( !ret.ok() ) { irods::log( PASSMSG( "l3CreateByObjInfo - failed in get_loc_for_hier_String", ret ) ); return -1; } fileCreateInp_t fileCreateInp; memset( &fileCreateInp, 0, sizeof( fileCreateInp ) ); rstrcpy( fileCreateInp.resc_name_, location.c_str(), MAX_NAME_LEN ); rstrcpy( fileCreateInp.resc_hier_, dataObjInfo->rescHier, MAX_NAME_LEN ); rstrcpy( fileCreateInp.objPath, dataObjInfo->objPath, MAX_NAME_LEN ); rstrcpy( fileCreateInp.addr.hostAddr, location.c_str(), NAME_LEN ); rstrcpy( fileCreateInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN ); fileCreateInp.mode = getFileMode( dataObjInp ); // =-=-=-=-=-=-=- // JMC - backport 4774 chkType = getchkPathPerm( rsComm, dataObjInp, dataObjInfo ); copyFilesystemMetadata( &dataObjInfo->condInput, &fileCreateInp.condInput ); if ( chkType == DISALLOW_PATH_REG ) { clearKeyVal( &fileCreateInp.condInput ); return PATH_REG_NOT_ALLOWED; } else if ( chkType == NO_CHK_PATH_PERM ) { fileCreateInp.otherFlags |= NO_CHK_PERM_FLAG; // JMC - backport 4758 } rstrcpy( fileCreateInp.in_pdmo, dataObjInfo->in_pdmo, MAX_NAME_LEN ); // =-=-=-=-=-=-=- // fileCreateOut_t* create_out = 0; std::string prev_resc_hier = fileCreateInp.resc_hier_; l3descInx = rsFileCreate( rsComm, &fileCreateInp, &create_out ); // update the dataObjInfo with the potential changes made by the resource - hcj rstrcpy( dataObjInfo->rescHier, fileCreateInp.resc_hier_, MAX_NAME_LEN ); rstrcpy( dataObjInfo->filePath, create_out->file_name, MAX_NAME_LEN ); /* file already exists ? */ while ( l3descInx <= 2 && retryCnt < 100 && getErrno( l3descInx ) == EEXIST ) { if ( resolveDupFilePath( rsComm, dataObjInfo, dataObjInp ) < 0 ) { break; } rstrcpy( fileCreateInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN ); free( create_out ); l3descInx = rsFileCreate( rsComm, &fileCreateInp, &create_out ); // update the dataObjInfo with the potential changes made by the resource - hcj rstrcpy( dataObjInfo->rescHier, fileCreateInp.resc_hier_, MAX_NAME_LEN ); rstrcpy( dataObjInfo->filePath, create_out->file_name, MAX_NAME_LEN ); retryCnt ++; } clearKeyVal( &fileCreateInp.condInput ); return ( l3descInx ); }
static int open_tcp_socket(ares_channel channel, struct server_state *server) { int s; struct sockaddr_in sin; #ifdef USE_IPV6 struct sockaddr_in6 sin6; #endif /* Acquire a socket. */ #ifdef USE_IPV6 assert(server->family == AF_INET || server->family == AF_INET6); s = (int)socket(server->family, SOCK_STREAM, 0); #else s = (int)socket(AF_INET, SOCK_STREAM, 0); #endif if (s == -1) return -1; if (make_socket_non_blocking(s)) { ares__kill_socket(s); return -1; } #ifdef WIN32 #define PORTABLE_INPROGRESS_ERR WSAEWOULDBLOCK #else #define PORTABLE_INPROGRESS_ERR EINPROGRESS #endif /* Connect to the server. */ #ifdef USE_IPV6 if (server->family == AF_INET6) { memset(&sin6, 0, sizeof(sin6)); sin6.sin6_family = AF_INET6; sin6.sin6_addr = server->addr6; sin6.sin6_port = channel->tcp_port; sin6.sin6_flowinfo = 0; sin6.sin6_scope_id = 0; // do i need to explicitly set the length? if (connect(s, (const struct sockaddr *) &sin6 , sizeof(sin6)) == -1 && getErrno() != PORTABLE_INPROGRESS_ERR) { ares__kill_socket(s); return -1; } } else // IPv4 DNS server { memset(&sin, 0, sizeof(sin)); sin.sin_family = AF_INET; sin.sin_addr = server->addr; sin.sin_port = channel->tcp_port; if (connect(s, (struct sockaddr *) &sin, sizeof(sin)) == -1 && getErrno() != PORTABLE_INPROGRESS_ERR) { ares__kill_socket(s); return -1; } } #else memset(&sin, 0, sizeof(sin)); sin.sin_family = AF_INET; sin.sin_addr = server->addr; sin.sin_port = channel->tcp_port; if (connect(s, (struct sockaddr *) &sin, sizeof(sin)) == -1 && getErrno() != PORTABLE_INPROGRESS_ERR) { ares__kill_socket(s); return -1; } #endif server->tcp_socket = s; return 0; }
// =-=-=-=-=-=-=-= // _rsFileSyncToArch - this the local version of rsFileSyncToArch. int _rsFileSyncToArch( rsComm_t* _comm, fileStageSyncInp_t* _sync_inp, fileSyncOut_t** _sync_out ) { // =-=-=-=-=-=-=- // XXXX need to check resource permission and vault permission // when RCAT is available // =-=-=-=-=-=-=- // prep if ( _sync_inp->objPath[0] == '\0' ) { std::stringstream msg; msg << __FUNCTION__; msg << " - Empty logical path."; irods::log( LOG_ERROR, msg.str() ); return SYS_INVALID_INPUT_PARAM; } // =-=-=-=-=-=-=- // make call to synctoarch via resource plugin irods::file_object_ptr file_obj( new irods::file_object( _comm, _sync_inp->objPath, _sync_inp->filename, "", 0, _sync_inp->mode, _sync_inp->flags ) ); file_obj->resc_hier( _sync_inp->rescHier ); // =-=-=-=-=-=-=- // pass condInput file_obj->cond_input( _sync_inp->condInput ); irods::error sync_err = fileSyncToArch( _comm, file_obj, _sync_inp->cacheFilename ); if ( !sync_err.ok() ) { if ( getErrno( sync_err.code() ) == ENOENT ) { // =-=-=-=-=-=-=- // the directory does not exist, lets make one int status = mkDirForFilePath( _comm, 0, _sync_inp->filename, _sync_inp->rescHier, getDefDirMode() ); if ( status < 0 ) { rodsLog( LOG_ERROR, "mkDirForFilePath failed in _rsFileSyncToArch with status %d", status ); return status; } } else if ( getErrno( sync_err.code() ) == EEXIST ) { // =-=-=-=-=-=-=- // an empty dir may be there, make the call to rmdir via the resource plugin irods::collection_object_ptr coll_obj( new irods::collection_object( _sync_inp->filename, _sync_inp->rescHier, 0, 0 ) ); coll_obj->cond_input( _sync_inp->condInput ); irods::error rmdir_err = fileRmdir( _comm, coll_obj ); if ( !rmdir_err.ok() ) { std::stringstream msg; msg << "fileRmdir failed for ["; msg << _sync_inp->filename; msg << "]"; irods::error err = PASSMSG( msg.str(), sync_err ); irods::log( err ); } } else { std::stringstream msg; msg << "fileSyncToArch failed for ["; msg << _sync_inp->filename; msg << "]"; irods::error err = PASSMSG( msg.str(), sync_err ); irods::log( err ); return sync_err.code(); } // =-=-=-=-=-=-=- // make call to synctoarch via resource plugin sync_err = fileSyncToArch( _comm, file_obj, _sync_inp->cacheFilename ); if ( !sync_err.ok() ) { std::stringstream msg; msg << "fileSyncToArch failed for ["; msg << _sync_inp->filename; msg << "]"; msg << sync_err.code(); irods::error err = PASSMSG( msg.str(), sync_err ); irods::log( err ); } } // if !sync_err.ok() // =-=-=-=-=-=-=- // has the file name has changed? if ( *_sync_out ) { rstrcpy( ( *_sync_out )->file_name, file_obj->physical_path().c_str(), MAX_NAME_LEN ); } return sync_err.code(); } // _rsFileSyncToArch
EFI_STATUS efi_main(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable) { InitializeLib(ImageHandle, SystemTable); CallConstructors(); EFI_STATUS Status; const char16_t* searchdir = u"\\EFI\\ChaiOS\\"; if (Status = SetWorkingDirectory(searchdir)) printf(u"Error setting working directory: %s\r\n", getError(Status)); CHAIOS_BOOT_FILES* bootfile = nullptr; while (bootfile = iterateBootFiles(bootfile)) { if (bootfile->loadLocation != nullptr) continue; //Support in-memory images EFI_FILE* file = OpenFile(bootfile->fileName, "r"); if (!file) { printf(u"Error: could not open %s: %s\r\n", bootfile->fileName, getError(getErrno())); } UINT64 fileSize = GetFileSize(file); VOID* bootfilebuf = kmalloc(fileSize+1); UINTN read = ReadFile(bootfilebuf, 1, fileSize, file); if (read < fileSize) printf(u"Read %d bytes, failed\r\n", read); else printf(u"Successfully read %d bytes\r\n", read); //Boot file is now loaded into memory CloseFile(file); bootfile->loadLocation = bootfilebuf; bootfile->fileSize = fileSize; if (bootfile->bootType == CHAIOS_BOOT_CONFIGURATION) { //We need to parse this now. INI format ((char*)bootfilebuf)[fileSize] = '\0'; ini_parse_string((const char*)bootfilebuf, &bootini_handler, nullptr); } } //size_t value = GetIntegerInput(u"Enter scrolling lines configuration: "); //set_scrolllines(value); UINT32 AutoMode = IterateGraphicsMode(&match_config_resoultion); EFI_GRAPHICS_OUTPUT_MODE_INFORMATION* info; UINTN SizeOfInfo; if (AutoMode == UINT32_MAX) { if (!EFI_ERROR(GetGraphicsModeInfo(AutoMode, &info, &SizeOfInfo))) { IterateGraphicsMode(&print_graphics_mode); size_t value = GetIntegerInput(u"Enter boot graphics mode: "); SetGraphicsMode(value); AutoMode = value; } } else { SetGraphicsMode(AutoMode); } if (!EFI_ERROR(GetGraphicsModeInfo(AutoMode, &info, &SizeOfInfo))) { printf(u"Graphics mode %d: %dx%d\r\n", AutoMode, info->HorizontalResolution, info->VerticalResolution); } puts(u"ChaiOS 0.09 UEFI Loader\r\n"); int majorver = SystemTable->Hdr.Revision / (1 << 16); int minorver = SystemTable->Hdr.Revision % (1 << 16); printf(u"Firmware Vendor: %s, version: %d (UEFI:%d.%d)\r\n", SystemTable->FirmwareVendor, SystemTable->FirmwareRevision, majorver, minorver); //Read ACPI configuration tables //startup_acpi(SystemTable); //startup_multiprocessor(); const size_t EARLY_PAGE_STACK_SIZE = 1024*1024; EFI_PHYSICAL_ADDRESS earlyPhypageStack = 0; if (EFI_ERROR(SystemTable->BootServices->AllocatePages(AllocateAnyPages, EfiLoaderData, EARLY_PAGE_STACK_SIZE / EFI_PAGE_SIZE, &earlyPhypageStack))) { puts(u"Could not allocate page stack\r\n"); return EFI_OUT_OF_RESOURCES; } SystemTable->BootServices->SetWatchdogTimer(0, 0, 0, nullptr); PrepareExitBootServices(); EfiMemoryMap map; map.MemMapSize = map.MapKey = map.DescriptorSize = map.DescriptorVersion = 0; SystemTable->BootServices->GetMemoryMap(&map.MemMapSize, nullptr, &map.MapKey, &map.DescriptorSize, &map.DescriptorVersion); //Give a nice bit of room to spare (memory map can change) map.MemMapSize += 16 * map.DescriptorSize; map.memmap = (EFI_MEMORY_DESCRIPTOR*)kmalloc(map.MemMapSize); //Allocate a nice buffer SystemTable->BootServices->GetMemoryMap(&map.MemMapSize, map.memmap, &map.MapKey, &map.DescriptorSize, &map.DescriptorVersion); printf(u"EFI Memory Map: Descriptor size %d\n", map.DescriptorSize); #if 0 //Dump the UEFI memory map to a file for testing EFI_FILE* file = OpenFile(u"efimap.dat", "w"); if (!file) { printf(u"Error: could not open %s: %s\r\n", u"efimap.dat", getError(getErrno())); } WriteFile(map.memmap, 1, map.MemMapSize, file); CloseFile(file); #endif if (EFI_ERROR(Status = SystemTable->BootServices->ExitBootServices(ImageHandle, map.MapKey))) { printf(u"Failed to exit boot services: %s\r\n", getError(Status)); UINTN index; SystemTable->BootServices->WaitForEvent(1, &SystemTable->ConIn->WaitForKey, &index); return EFI_SUCCESS; } //We need to take control of the hardware now. Setup basic memory management setLiballocAllocator(nullptr, nullptr); InitializePmmngr(map, (void*)earlyPhypageStack, EARLY_PAGE_STACK_SIZE); puts(u"Physical memory manager intialized\n"); arch_initialize_paging(); puts(u"Paging initialized\n"); setLiballocAllocator(&arch_allocate_pages, &arch_free_pages); //Now load the OS! bootfile = nullptr; kimage_entry kentry = nullptr; KLOAD_HANDLE kernel = NULL; while (bootfile = iterateBootFiles(bootfile)) { printf(u"Boot file: %s @ %x, length %d, type %d\n", bootfile->fileName, bootfile->loadLocation, bootfile->fileSize, bootfile->bootType); if (!bootfile->loadLocation) continue; if (bootfile->bootType == CHAIOS_DLL) { KLOAD_HANDLE dll = LoadImage(bootfile->loadLocation, bootfile->fileName); if (GetProcAddress(dll, "memcpy")) { set_memcpy((memcpy_proc)GetProcAddress(dll, "memcpy")); } } else if (bootfile->bootType == CHAIOS_KERNEL) { kernel = LoadImage(bootfile->loadLocation, bootfile->fileName); kentry = GetEntryPoint(kernel); } } size_t kstacksize = GetStackSize(kernel); if (!paging_map(stackaddr, PADDR_T_MAX, kstacksize, PAGE_ATTRIBUTE_WRITABLE)) { puts(u"Error: could not allocate kernel stack\n"); while (1); } KERNEL_BOOT_INFO bootinfo; fill_pmmngr_info(bootinfo.pmmngr_info); fill_arch_paging_info(bootinfo.paging_info); fill_modloader_info(bootinfo.modloader_info); get_framebuffer_info(bootinfo.fbinfo); populate_kterm_info(bootinfo.kterm_status); bootinfo.efi_system_table = SystemTable; bootinfo.memory_map = ↦ bootinfo.loaded_files = &bootfiles; bootinfo.boottype = CHAIOS_BOOT_TYPE_UEFI; bootinfo.printf_proc = &printf; bootinfo.puts_proc = &puts; printf(u"Success: Kernel entry point at %x, stack at %x, length %x\n", kentry, stackaddr, kstacksize); call_kernel(&bootinfo, kentry, stackaddr, kstacksize); puts(u"Kernel returned"); while (1); }
bool_t sendMessage( Socket fd, char* buf, int l, unsigned int dstIp, unsigned short dstPort) { int s; if (fd == INVALID_SOCKET) return FALSE; if ( dstPort == 0 ) { /* sending on a connected port */ s = send(fd,buf,l,0); } else { struct sockaddr_in to; int toLen = sizeof(to); if (dstIp == 0) { ortp_error("stun_udp: invalid IP provided (dstIP==0)"); return FALSE; } memset(&to,0,toLen); to.sin_family = AF_INET; to.sin_port = htons(dstPort); to.sin_addr.s_addr = htonl(dstIp); s = sendto(fd, buf, l, 0,(struct sockaddr*)&to, toLen); } if ( s == SOCKET_ERROR ) { int e = getErrno(); switch (e) { case ECONNREFUSED: case EHOSTDOWN: case EHOSTUNREACH: { /* quietly ignore this */ } break; case EAFNOSUPPORT: { ortp_error("stun_udp: err EAFNOSUPPORT in send"); } break; default: { #if !defined(_WIN32_WCE) ortp_error("stun_udp: err %i %s in send", e, strerror(e)); #else ortp_error("stun_udp: err %i in send", e); #endif } } return FALSE; } if ( s == 0 ) { ortp_error("stun_udp: no data sent in send"); return FALSE; } if ( s != l ) { ortp_error("stun_udp: only %i out of %i bytes sent", s, l); return FALSE; } return TRUE; }
bool_t getMessage( Socket fd, char* buf, int* len, unsigned int* srcIp, unsigned short* srcPort) { /* assert( fd != INVALID_SOCKET ); */ int originalSize = *len; struct sockaddr_in from; int fromLen = sizeof(from); int err; struct timeval tv; fd_set fdSet; #if defined(WIN32) || defined(_WIN32_WCE) unsigned int fdSetSize; #else int fdSetSize; #endif if (originalSize <= 0) { return FALSE; } tv.tv_sec=1; tv.tv_usec=0; /* 150 ms */ FD_ZERO(&fdSet); fdSetSize=0; FD_SET(fd,&fdSet); fdSetSize = fd+1; err = select(fdSetSize, &fdSet, NULL, NULL, &tv); if ( err == SOCKET_ERROR ) { int e = getErrno(); switch (e) { case ENOTSOCK: ortp_error("stun_udp: Error fd not a socket"); break; case ECONNRESET: ortp_error("stun_udp: Error connection reset - host not reachable"); break; default: ortp_error("stun_udp: Socket Error=%i", e); } return FALSE; } if (err==0) { ortp_error("stun_udp: Connection timeout with stun server!"); *len = 0; return FALSE; } if (FD_ISSET (fd, &fdSet)) { *len = recvfrom(fd, buf, originalSize, 0, (struct sockaddr *)&from, (socklen_t*)&fromLen); if ( *len == SOCKET_ERROR ) { int e = getErrno(); switch (e) { case ENOTSOCK: ortp_error("stun_udp: Error fd not a socket"); break; case ECONNRESET: ortp_error("stun_udp: Error connection reset - host not reachable"); break; default: ortp_error("stun_udp: Socket Error=%i", e); } return FALSE; } if ( *len < 0 ) { ortp_error("stun_udp: socket closed? negative len"); return FALSE; } if ( *len == 0 ) { ortp_error("stun_udp: socket closed? zero len"); return FALSE; } *srcPort = ntohs(from.sin_port); *srcIp = ntohl(from.sin_addr.s_addr); if ( (*len)+1 >= originalSize ) { ortp_error("stun_udp: Received a message that was too large"); return FALSE; } buf[*len]=0; return TRUE; } return FALSE; }
Socket openPort( unsigned short port, unsigned int interfaceIp ) { struct sockaddr_in addr; Socket fd; fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); if ( fd == INVALID_SOCKET ) { ortp_error("stun_udp: Could not create a UDP socket"); return INVALID_SOCKET; } memset((char*) &(addr),0, sizeof((addr))); addr.sin_family = AF_INET; addr.sin_addr.s_addr = htonl(INADDR_ANY); addr.sin_port = htons(port); if ( (interfaceIp != 0) && ( interfaceIp != 0x100007f ) ) { addr.sin_addr.s_addr = htonl(interfaceIp); //ortp_debug("Binding to interface 0x%lu\n",(unsigned long) htonl(interfaceIp)); } if ( bind( fd,(struct sockaddr*)&addr, sizeof(addr)) != 0 ) { int e = getErrno(); switch (e) { case 0: { ortp_error("stun_udp: Could not bind socket");; return INVALID_SOCKET; } case EADDRINUSE: { ortp_error("stun_udp: Port %i for receiving UDP is in use", port); return INVALID_SOCKET; } break; case EADDRNOTAVAIL: { ortp_error("stun_udp: Cannot assign requested address"); return INVALID_SOCKET; } break; default: { #if !defined(_WIN32_WCE) ortp_error("stun_udp: Could not bind UDP receive port Error=%i %s", e, strerror(e)); #else ortp_error("stun_udp: Could not bind UDP receive port Error=%i", e); #endif return INVALID_SOCKET; } break; } } ortp_debug("stun: opened port %i with fd %i\n", port, fd); /* assert( fd != INVALID_SOCKET ); */ return fd; }
const char * posix_error_exception::what() const noexcept { return ("Error occured - " + Logger::getPosixErrorDescription(getErrno()) + " - while " + getWhile()).c_str(); }
// =-=-=-=-=-=-=- // local implementation of put int _rsFilePut( rsComm_t* _comm, fileOpenInp_t* _put_inp, bytesBuf_t* _put_bbuf, rodsServerHost_t* _server_host ) { int fd = 0; // =-=-=-=-=-=-=- // NOTE:: this test does not seem to work for i86 solaris if ( ( _put_inp->otherFlags & FORCE_FLAG ) != 0 ) { // =-=-=-=-=-=-=- // create one if it does not exist */ _put_inp->flags |= O_CREAT; fd = _rsFileOpen( _comm, _put_inp ); } else { fd = _rsFileCreate( _comm, _put_inp, _server_host ); } // else // =-=-=-=-=-=-=- // log, error if any if ( fd < 0 ) { if ( getErrno( fd ) == EEXIST ) { rodsLog( LOG_DEBUG1, "_rsFilePut: filePut for %s, status = %d", _put_inp->fileName, fd ); } else if ( fd != DIRECT_ARCHIVE_ACCESS ) { rodsLog( LOG_DEBUG, "_rsFilePut: filePut for %s, status = %d", _put_inp->fileName, fd ); } return ( fd ); } // =-=-=-=-=-=-=- // call write for resource plugin irods::file_object_ptr file_obj( new irods::file_object( _comm, _put_inp->objPath, _put_inp->fileName, _put_inp->resc_hier_, fd, 0, 0 ) ); file_obj->in_pdmo( _put_inp->in_pdmo ); file_obj->cond_input( _put_inp->condInput ); irods::error write_err = fileWrite( _comm, file_obj, _put_bbuf->buf, _put_bbuf->len ); int write_code = write_err.code(); // =-=-=-=-=-=-=- // log errors, if any if ( write_code != _put_bbuf->len ) { if ( write_code >= 0 ) { std::stringstream msg; msg << "fileWrite failed for ["; msg << _put_inp->fileName; msg << "] towrite ["; msg << _put_bbuf->len; msg << "] written ["; msg << write_code << "]"; irods::error err = PASSMSG( msg.str(), write_err ); irods::log( err ); write_code = SYS_COPY_LEN_ERR; } else { std::stringstream msg; msg << "fileWrite failed for ["; msg << _put_inp->fileName; msg << "]"; irods::error err = PASSMSG( msg.str(), write_err ); irods::log( err ); } } // =-=-=-=-=-=-=- // close up after ourselves irods::error close_err = fileClose( _comm, file_obj ); if ( !close_err.ok() ) { irods::error err = PASSMSG( "error on close", close_err ); irods::log( err ); } // =-=-=-=-=-=-=- // return 'write_err code' as this includes this implementation // assumes we are returning the size of the file 'put' via fileWrite return write_code; } // _rsFilePut
int _rsChkNVPathPerm( rsComm_t *rsComm, fileOpenInp_t *chkNVPathPermInp ) { struct stat myFileStat; int sysUid; char tmpPath[MAX_NAME_LEN]; int len; char *tmpPtr; if ( chkNVPathPermInp->objPath[0] == '\0' ) { std::stringstream msg; msg << __FUNCTION__; msg << " - Empty logical path."; irods::log( LOG_ERROR, msg.str() ); return -1; } /* Need to match path's owner uid with sysUid */ sysUid = rsComm->clientUser.sysUid; if ( sysUid < 0 ) { /* have tried before */ return SYS_NO_PATH_PERMISSION; } else if ( sysUid == 0 ) { sysUid = rsComm->clientUser.sysUid = getUnixUid( rsComm->clientUser.userName ); if ( sysUid < 0 ) { rsComm->clientUser.sysUid = sysUid; return SYS_NO_PATH_PERMISSION; } } rstrcpy( tmpPath, chkNVPathPermInp->fileName, MAX_NAME_LEN ); len = strlen( tmpPath ); irods::error stat_err; while ( 1 ) { irods::file_object_ptr file_obj( new irods::file_object( rsComm, chkNVPathPermInp->objPath, tmpPath, chkNVPathPermInp->resc_hier_, 0, 0, 0 ) ); stat_err = fileStat( rsComm, file_obj, &myFileStat ); if ( stat_err.code() >= 0 ) { break; } else if ( errno == EEXIST || getErrno( stat_err.code() ) == EEXIST ) { /* go back */ tmpPtr = tmpPath + len; while ( len > 0 ) { len --; if ( *tmpPtr == '/' ) { *tmpPtr = '\0'; break; } tmpPtr--; } if ( len > 0 ) { /* give it more tries */ continue; } else { break; } } else { break; } } if ( stat_err.code() < 0 ) { return SYS_NO_PATH_PERMISSION; } if ( sysUid != ( int ) myFileStat.st_uid && ( myFileStat.st_mode & S_IWOTH ) == 0 ) { return SYS_NO_PATH_PERMISSION; } else { return 0; } }
int l3FilePutSingleBuf (rsComm_t *rsComm, int l1descInx, bytesBuf_t *dataObjInpBBuf) { dataObjInfo_t *dataObjInfo; int rescTypeInx; fileOpenInp_t filePutInp; int bytesWritten; dataObjInp_t *dataObjInp; int retryCnt = 0; int chkType; dataObjInfo = L1desc[l1descInx].dataObjInfo; dataObjInp = L1desc[l1descInx].dataObjInp; if (getStructFileType (dataObjInfo->specColl) >= 0) { subFile_t subFile; memset (&subFile, 0, sizeof (subFile)); rstrcpy (subFile.subFilePath, dataObjInfo->subPath, MAX_NAME_LEN); rstrcpy (subFile.addr.hostAddr, dataObjInfo->rescInfo->rescLoc, NAME_LEN); subFile.specColl = dataObjInfo->specColl; subFile.mode = getFileMode (dataObjInp); subFile.flags = O_WRONLY | dataObjInp->openFlags; #if 0 if (getValByKey (&dataObjInp->condInput, FORCE_FLAG_KW) != NULL) { #else if ((L1desc[l1descInx].replStatus & OPEN_EXISTING_COPY) != 0) { #endif subFile.flags |= FORCE_FLAG; } bytesWritten = rsSubStructFilePut (rsComm, &subFile, dataObjInpBBuf); return (bytesWritten); } rescTypeInx = dataObjInfo->rescInfo->rescTypeInx; switch (RescTypeDef[rescTypeInx].rescCat) { case FILE_CAT: memset (&filePutInp, 0, sizeof (filePutInp)); #if 0 if (getValByKey (&dataObjInp->condInput, FORCE_FLAG_KW) != NULL) { #else if ((L1desc[l1descInx].replStatus & OPEN_EXISTING_COPY) != 0) { #endif filePutInp.otherFlags |= FORCE_FLAG; } filePutInp.fileType = (fileDriverType_t)RescTypeDef[rescTypeInx].driverType; rstrcpy (filePutInp.addr.hostAddr, dataObjInfo->rescInfo->rescLoc, NAME_LEN); rstrcpy (filePutInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN); filePutInp.mode = getFileMode (dataObjInp); #ifdef FILESYSTEM_META copyFilesystemMetadata(&dataObjInfo->condInput, &filePutInp.condInput); #endif filePutInp.flags = O_WRONLY | dataObjInp->openFlags; chkType = getchkPathPerm (rsComm, L1desc[l1descInx].dataObjInp, L1desc[l1descInx].dataObjInfo); if (chkType == DISALLOW_PATH_REG) { return PATH_REG_NOT_ALLOWED; } else if (chkType == NO_CHK_PATH_PERM) { filePutInp.otherFlags |= NO_CHK_PERM_FLAG; } bytesWritten = rsFilePut (rsComm, &filePutInp, dataObjInpBBuf); /* file already exists ? */ while (bytesWritten < 0 && retryCnt < 10 && (filePutInp.otherFlags & FORCE_FLAG) == 0 && getErrno (bytesWritten) == EEXIST) { if (resolveDupFilePath (rsComm, dataObjInfo, dataObjInp) < 0) { break; } rstrcpy (filePutInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN); bytesWritten = rsFilePut (rsComm, &filePutInp, dataObjInpBBuf); retryCnt ++; } break; default: rodsLog (LOG_NOTICE, "l3Open: rescCat type %d is not recognized", RescTypeDef[rescTypeInx].rescCat); bytesWritten = SYS_INVALID_RESC_TYPE; break; } return (bytesWritten); }