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);
}
