Google Git
Sign in
apache / harmony-classlib / 98ed8d7502b0ed8a492afeb8b24aa697c9324423 / . / modules / portlib / src / main / native / a2e / unix / atoe.c
blob: e94ce047482ee3181a125f265f665dd4399570da [file] [log] [blame]
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* DESCRIPTION:
* Generic ASCII to EBCDIC character conversion. This file defines
* a number of "wrapper" functions to transparently convert between
* ASCII and EBCDIC. Each function calls a platform specific function
* (defined elsewhere) to perform the actual conversion.
* ===========================================================================
*/
/*
* ======================================================================
* Disable the redefinition of the system IO functions, this
* prevents two ATOE functions calling themselves.
* ======================================================================
*/
#undef HY_ATOE
/*
* ======================================================================
* Include all system header files.
* ======================================================================
*/
#define _OPEN_SYS_FILE_EXT /* For SETCVTOFF */
#ifndef __SUSV3 /* For dlfcn.h */
#define __SUSV3
#endif
#include <unistd.h>
#include <fcntl.h> /* <--SETCVTOFF in here */
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <utime.h>
#include <pwd.h>
#include <grp.h>
#include <dirent.h>
#include <stdarg.h>
#include <ctype.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <locale.h>
#include <netdb.h>
#include <dll.h>
#include <errno.h>
#include <iconv.h>
#include <langinfo.h>
#include <arpa/inet.h>
#include <sys/stat.h>
#include <sys/utsname.h>
#include <sys/ipc.h>
#include <limits.h>
#include <_Ccsid.h>
#include <dlfcn.h>
#define check_fcntl_init() (1)
#define set_SETCVTOFF()
#define use_fcntl (0)
int env_mutex_initialized = 0;
/* Whether file tagging enabled by user */
static int fileTaggingEnabled = 0;
/* CCSID for new files */
static __ccsid_t newFileCCSID = 0;
/*
* ======================================================================
* ASCII<=>EBCDIC translate tables built using iconv()
* ======================================================================
*/
#define BUFLEN 6144
#define CONV_TABLE_SIZE 256
char a2e_tab[CONV_TABLE_SIZE];
char e2a_tab[CONV_TABLE_SIZE];
/*
* ======================================================================
* Define ae2,e2a,a2e_string, e2a_string
* ======================================================================
*/
#include "atoe.h"
int atoe_vsnprintf(char *str, size_t count, const char *fmt, va_list args);
int atoe_fprintf(FILE *, const char *, ...);
struct passwd *etoa_passwd(struct passwd *e_passwd);
/*
* ======================================================================
* A simple linked list of ascii environment variable entries;
* each entry is added as a result of a getenv() or putenv() as
* reflected through the EBCDIC environment maintained by the system.
* This improves performance by having each environment variable
* converted only once, and also avoids storage leaks with repeated
* calls which refer to the same variable.
* ======================================================================
*/
struct ascii_envvar {
struct ascii_envvar *next;
char *name;
char *value;
};
typedef struct ascii_envvar envvar_t;
/* Anchor entry */
envvar_t env_anchor = {NULL, NULL, NULL};
/* Mutex for single-threading list updates */
pthread_mutex_t env_mutex;
char* sysTranslate(const char *source, int length, char *trtable, char* xlate_buf)
{
return sysTranslateASM( source, length, trtable, xlate_buf );
}
/**************************************************************************
* name - enumEnvvar
* description -
* enumEnvvar() takes an input pointer that is either null for
* the first call or contains the result returned from a previous
* call. It will also modify two input pointer parameters to point
* to the current envar name string and the envar value string. The
* strings will contain ascii characters.
* parameters -
* returns -
*************************************************************************/
void *
enumEnvvar(void * input_ptr, char ** name, char ** value) {
if (0 == env_anchor.next ) { /* empty envar list case */
*name = 0;
*value= 0;
return(void *) 0;
}
if (0 == input_ptr) { /* non-empty list, first call case */
*name = env_anchor.name;
*value = env_anchor.value;
return(void *) env_anchor.next;
} else { /* walk the list case */
envvar_t * curr_env= (envvar_t *)input_ptr;
*name = curr_env->name;
*value = curr_env->value;
return(void *) curr_env->next; /* next = 0 signals end of list */
}
}
/**************************************************************************
* name - getEnvvar
* description -
* getEnvvar() - returns a pointer to the ascii_envvar structure
* for the environment variable specified by name, or NULL if there
* is no entry for that name. No need to serialise this code.
* parameters -
* returns -
*************************************************************************/
envvar_t *
getEnvvar(char *name)
{
envvar_t *envvar = env_anchor.next;
while (envvar != NULL) {
if (strcmp(name, envvar->name) == 0)
break;
envvar = envvar->next;
}
return envvar;
}
/**************************************************************************
* name - putEnvvar
* description -
* putEnvvar() - updates the ascii_envvar structure for the variable
* specified by name if it already exists, or creates a new ascii_envvar
* structure if it does not, and returns a pointer to the entry.
* This function is single_threaded.
* parameters -
* returns -
*************************************************************************/
envvar_t *
putEnvvar(char *name, char *value, envvar_t *updvar)
{
envvar_t *envvar;
if (!env_mutex_initialized) {
/* First time in - initialise the mutex */
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutex_init(&env_mutex, &attr);
env_mutex_initialized = 1;
}
/* Grab the lock */
pthread_mutex_lock(&env_mutex);
if (updvar != NULL) {
/* Update the existing entry */
envvar = updvar;
free(envvar->value);
envvar->value = strdup(value);
} else {
/* Add a new entry to the list */
envvar = &env_anchor;
while (envvar->next != NULL) {
envvar = envvar->next;
}
envvar->next = malloc(sizeof(envvar_t));
envvar = envvar->next;
envvar->next = NULL;
envvar->name = strdup(name);
envvar->value = strdup(value);
}
/* Release the lock */
pthread_mutex_unlock(&env_mutex);
return envvar;
}
/**************************************************************************
* name - a2e_func
* description - Function implementation of a2e macro, for use by DLLs
* that don't want to have to link with sysTranslate.o
* parameters - str, ASCII string to convert
* len, Length of str
* returns - Converted EBCDIC string
*************************************************************************/
char *
a2e_func(char *str, int len)
{
return a2e(str, len);
}
/**************************************************************************
* name - e2a_func
* description - Function implementation of e2a macro, for use by DLLs
* that don't want to have to link with sysTranslate.o
* parameters - str, EBCIDC string to convert
* len, Length of str
* returns - Converted ASCII string
*************************************************************************/
char *
e2a_func(char *str, int len)
{
return e2a(str, len);
}
/**************************************************************************
* name - atoe_getenv
* description -
* Returns a pointer to the value of the environment
* variable specified by a_name. The ascii environment is searched first,
* and the value is returned if found. If not, the EBCDIC environment
* is checked, and an ascii entry is created if it is found. If not,
* NULL is returned.
* parameters -
* returns -
*************************************************************************/
char *
atoe_getenv(const char *name)
{
char *value, *e_name, *e_value;
envvar_t *envvar;
if (name == NULL) {
return NULL;
}
if ((envvar = getEnvvar((char *)name)) != NULL) {
/* We already have the variable in ascii */
return envvar->value;
}
/* Get the EBCIDC value from the system */
e_name = a2e_string(name);
e_value = getenv(e_name);
free(e_name);
if (e_value == NULL) {
/* Variable is not currently defined */
return NULL;
}
/* Create a new ascii environment variable entry */
value = e2a_string(e_value);
envvar = putEnvvar((char *)name, value, NULL);
free(value);
return envvar->value;
}
/**************************************************************************
* name - atoe_putenv
* description -
* Issues putenv() to set the system EBCDIC environment
* then updates the ascii environment
* parameters -
* returns -
*************************************************************************/
int
atoe_putenv(const char *envstr)
{
char *w_envstr, *name, *value;
envvar_t *envvar;
int result;
/* Set the system EBCDIC environment - don't free w_envstr as it's memory is held by the environment */
w_envstr = a2e_string(envstr);
result = putenv(w_envstr);
if (result == 0) {
/* Update the ascii environment */
char *asciienv = strdup(envstr);
/*
* The name is everything upto the first '='s character and the value
* is everything after it.
*/
name = asciienv;
value = strchr(asciienv, '=');
*value = '\0'; /* Add '\0' so name is NULL termintated. */
value++; /* Value is now everything after the '='. */
envvar = putEnvvar(name, value, getEnvvar(name));
free(asciienv);
}
return result;
}
/**************************************************************************
* name - atoe_perror
* description -
* parameters -
* returns -
*************************************************************************/
void
atoe_perror( const char *string)
{
char *e;
e = a2e_string(string);
perror(e);
free(e);
return;
}
/**************************************************************************
* name - atoe_enableFileTagging
* description - Enables tagging of all new files to the specified ccsid
* parameters - ccsid - Required CCSID for file tags
* returns - none
*************************************************************************/
void
atoe_setFileTaggingCcsid(void *pccsid) {
__ccsid_t ccsid = *(__ccsid_t*) pccsid;
newFileCCSID = ccsid;
}
/**************************************************************************
* name - fileTagRequired
* description - Determines whether or not a specified file needs tagging
* parameters - filename (platform encoded)
* returns - 1 if file tagging enabled and file doesn't already exist.
* 0 otherwise
*************************************************************************/
static int
fileTagRequired(const char *filename) {
struct stat sbuf;
if (fileTaggingEnabled && newFileCCSID != 0 &&
(stat(filename,&sbuf) == -1 && errno == ENOENT) ) {
return 1;
}
return 0;
}
/**************************************************************************
* name - setFileTag
* description - Sets the file tag to newFileCCSID for the specified file
* descriptor
* parameters - fd - open file descriptor of file for tagging
* returns - none
*************************************************************************/
static void
setFileTag(int fd) {
struct file_tag tag;
tag.ft_ccsid = newFileCCSID;
tag.ft_txtflag = 1;
tag.ft_deferred = 0;
tag.ft_rsvflags = 0;
fcntl(fd, F_SETTAG, &tag);
}
/**************************************************************************
* name - atoe_tagged_open
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_open( const char *fname, int options, ...)
{
int fd;
int mode;
int tagFile;
va_list args;
char *f;
check_fcntl_init();
/* See if the file needs to be tagged */
tagFile = fileTagRequired(fname);
f = a2e_string(fname);
va_start(args,options);
if ( options & O_CREAT ) {
mode = va_arg(args, int);
} else {
mode = 0;
}
va_end(args);
fd = open(f,options,mode);
if ( (fd != -1) && /* file descriptor ok? */
(use_fcntl) ) /* OS level is ok */
{
set_SETCVTOFF();
}
if (fd != -1) { /* file descriptor ok? */
if (tagFile) {
setFileTag(fd);
}
}
free(f);
return fd;
}
/**************************************************************************
* name - atoe_tempnam
* description -
* parameters -
* returns -
*************************************************************************/
char *
atoe_tempnam( const char *dir, char *pfx)
{
char *tempfn = 0;
char *a = 0;
char *d = a2e_string(dir);
char *p = a2e_string(pfx);
if (( tempfn = tempnam(d,p)) == 0 ) {
atoe_fprintf(stderr,"Creation of temp file %s/%s failed.\n",dir,pfx);
} else {
a = e2a_string(tempfn);
free(tempfn);
}
free(d);
free(p);
return a;
}
/**************************************************************************
* name - atoe_stat
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_stat( const char *pathname, struct stat *sbuf)
{
int rc;
char *e;
e = a2e_string(pathname);
rc = stat(e,sbuf);
free(e);
return rc;
}
/**************************************************************************
* name - atoe_lstat
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_lstat( const char *pathname, struct stat *sbuf)
{
int rc;
char *e;
e = a2e_string(pathname);
rc = lstat(e,sbuf);
free(e);
return rc;
}
/**************************************************************************
* name - atoe_fopen
* description -
* parameters -
* returns -
*************************************************************************/
FILE *
atoe_fopen( const char *filename, char *mode)
{
FILE *outfp;
char *f,*m;
int fd = -1; /* file descriptor */
check_fcntl_init();
f = a2e_string(filename);
m = a2e_string(mode);
outfp = fopen(f,m);
if ( (outfp != NULL) && /* fopen() ok? */
(use_fcntl) && /* OS level is ok */
( (fd = fileno(outfp)) != -1)) /* have a file descriptor? */
{
set_SETCVTOFF();
}
free(f);
free(m);
return outfp;
}
/**************************************************************************
* name - atoe_freopen
* description -
* parameters -
* returns -
*************************************************************************/
FILE *
atoe_freopen(const char *filename, char *mode, FILE *stream)
{
FILE *outfp;
char *f,*m;
int fd = -1; /* file descriptor */
check_fcntl_init();
f = a2e_string(filename);
m = a2e_string(mode);
outfp = freopen(f, m, stream);
if ( (outfp != NULL) && /* fopen() ok? */
(use_fcntl) && /* OS level is ok */
( (fd = fileno(outfp)) != -1)) /* have a file descriptor? */
{
set_SETCVTOFF();
}
free(f);
free(m);
return outfp;
}
/**************************************************************************
* name - atoe_mkdir
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_mkdir( const char *pathname, mode_t mode)
{
int rc;
char *e;
e = a2e_string(pathname);
rc = mkdir(e, mode);
free(e);
return rc;
}
/**************************************************************************
* name - atoe_remove
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_remove( const char *pathname)
{
int rc;
char *e;
e = a2e_string(pathname);
rc = remove(e);
free(e);
return rc;
}
/**************************************************************************
* name - atoe_strerror
* description -
* parameters -
* returns -
*************************************************************************/
#define ERRNO_CACHE_SIZE 250
typedef struct ascii_errno_t {
int errnum;
char *ascii_msg;
} ascii_errno_t;
static ascii_errno_t errno_cache[ERRNO_CACHE_SIZE];
static int errno_cache_next = 0;
static pthread_mutex_t strerror_mutex = PTHREAD_MUTEX_INITIALIZER;
static int strerror_initialized = 0;
char *
atoe_strerror(int errnum)
{
char *a,*e;
int index;
pthread_mutex_lock(&strerror_mutex);
if (0 == strerror_initialized) {
for (index=0; index<ERRNO_CACHE_SIZE; index++) {
errno_cache[index].errnum = -1;
errno_cache[index].ascii_msg = 0;
}
strerror_initialized = 1;
}
for (index=0;
index<ERRNO_CACHE_SIZE, errno_cache[index].errnum!=-1;
index++) {
if (errnum == errno_cache[index].errnum) {
pthread_mutex_unlock(&strerror_mutex);
return errno_cache[index].ascii_msg;
}
}
e = strerror(errnum);
a = e2a_string(e);
errno_cache[errno_cache_next].errnum = errnum;
if (errno_cache[errno_cache_next].ascii_msg)
free(errno_cache[errno_cache_next].ascii_msg);
errno_cache[errno_cache_next].ascii_msg = a;
if (++errno_cache_next == ERRNO_CACHE_SIZE)
errno_cache_next = 0;
pthread_mutex_unlock(&strerror_mutex);
return a;
}
/**************************************************************************
* name - atoe_getcwd
* description -
* parameters -
* returns -
*************************************************************************/
char *
atoe_getcwd(char *buffer, size_t size)
{
char *abuf;
if (getcwd(buffer,size) == NULL) {
atoe_fprintf(stderr,"atoe_getcwd error: %s\n",
errno==ERANGE ? "buffer too small" : atoe_strerror(errno));
buffer = NULL;
} else {
abuf = e2a(buffer,size);
memcpy(buffer,abuf,size);
free(abuf);
}
return buffer;
}
/**************************************************************************
* name - atoe_fgets
* description -
* parameters -
* returns -
*************************************************************************/
char *
atoe_fgets (char *buffer, int num, FILE *file)
{
char *abuf;
if (fgets(buffer, num, file)) {
int len = strlen(buffer);
abuf = e2a(buffer,len);
memcpy(buffer,abuf,len);
free(abuf);
return buffer;
}
return(char *)0;
}
/**************************************************************************
* name - atoe_gets
* description -
* parameters -
* returns -
*************************************************************************/
char *
atoe_gets(char *buffer)
{
char *abuf;
if (gets(buffer)) {
int len = strlen(buffer);
abuf = e2a(buffer,len);
memcpy(buffer,abuf,len);
free(abuf);
return buffer;
}
return(char *)0;
}
/**************************************************************************
* name - atoe_unlink
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_unlink( const char *pathname)
{
int rc;
char *e;
e = a2e_string(pathname);
rc = unlink(e);
free(e);
return rc;
}
/**************************************************************************
* name - atoe_unlink
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_rmdir( const char *pathname)
{
int rc;
char *e;
e = a2e_string(pathname);
rc = rmdir(e);
free(e);
return rc;
}
/**************************************************************************
* name - atoe_access
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_access( const char *pathname, int how)
{
int rc;
char *e;
e = a2e_string(pathname);
rc = access(e, how);
free(e);
return rc;
}
/**************************************************************************
* name - atoe_opendir
* description -
* parameters -
* returns -
*************************************************************************/
DIR *
atoe_opendir( const char *dirname)
{
DIR *dir;
char *e;
e = a2e_string(dirname);
dir = opendir(e);
free(e);
return dir;
}
/**************************************************************************
* name - atoe_readdir
* description -
* parameters -
* returns -
*************************************************************************/
struct dirent *
atoe_readdir(DIR *dir) {
struct dirent *d;
char * a;
d = readdir(dir);
if (d == NULL) return NULL;
a = e2a_string(d->d_name);
strcpy(d->d_name, a);
free(a);
return d;
}
/**************************************************************************
* name - atoe_realpath
* description -
* parameters -
* returns -
*************************************************************************/
char *
atoe_realpath(const char *file_name, char *resolved_name)
{
char e_resolved_name[MAXPATHLEN];
char *e_file_name, *p;
e_file_name = a2e_string(file_name);
p = realpath(e_file_name, e_resolved_name);
if (p == NULL) return p;
p = e2a_string(e_resolved_name);
strcpy(resolved_name, p);
free(p);
return resolved_name;
}
/**************************************************************************
* name - atoe_rename
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_rename(const char *oldname, const char *newname)
{
int rc;
char *o,*n;
o = a2e_string(oldname);
n = a2e_string(newname);
rc = rename(o, n);
free(o);
free(n);
return rc;
}
/**************************************************************************
* name - atoe_getpwuid
* description -
* parameters -
* returns -
*************************************************************************/
struct passwd *
atoe_getpwuid(uid_t uid) {
return etoa_passwd(getpwuid(uid));
}
/**************************************************************************
* name - atoe_getpwnam
* description -
* parameters -
* returns -
*************************************************************************/
struct passwd *
atoe_getpwnam(const char *name) {
struct passwd *e_passwd;
char *e_name;
e_name = a2e_string(name);
e_passwd = getpwnam(e_name);
free(e_name);
return etoa_passwd(e_passwd);
}
/**************************************************************************
* name - etoa_passwd
* description -
* parameters -
* returns -
*************************************************************************/
struct passwd *
etoa_passwd(struct passwd *e_passwd) {
struct passwd *a_passwd = NULL;
if (e_passwd != NULL) {
a_passwd = (struct passwd *)malloc(sizeof(struct passwd));
if (a_passwd != NULL) {
a_passwd->pw_name = e2a_string(e_passwd->pw_name);
a_passwd->pw_uid = e_passwd->pw_uid;
a_passwd->pw_gid = e_passwd->pw_gid;
a_passwd->pw_dir = e2a_string(e_passwd->pw_dir);
a_passwd->pw_shell = e2a_string(e_passwd->pw_shell);
}
}
return a_passwd;
}
/**************************************************************************
* name - atoe_getlogin
* description -
* parameters -
* returns -
*************************************************************************/
char *
atoe_getlogin(void)
{
char *e_login;
char *a_login = NULL;
e_login = getlogin();
if (e_login != NULL) {
a_login = e2a_string(e_login);
}
return a_login;
}
/**************************************************************************
* name - etoa_group
* description -
* parameters -
* returns -
*************************************************************************/
struct group *
e2a_group(struct group *e_group) {
struct group *a_group = NULL;
if (e_group != NULL) {
a_group = (struct group *)malloc(sizeof(struct group));
if (a_group != NULL) {
char **e_member = NULL;
char **a_member = NULL;
int arraySize = 0;
a_group->gr_name = e2a_string(e_group->gr_name);
a_group->gr_gid = e_group->gr_gid;
for(e_member = e_group->gr_mem; *e_member != NULL; e_member++) {
arraySize++;
}
a_group->gr_mem = (char **)malloc((arraySize+1)*sizeof(char*));
if (a_group->gr_mem != NULL) {
for(e_member = e_group->gr_mem, a_member = a_group->gr_mem;
*e_member != NULL;
e_member++, a_member++) {
*a_member = e2a_string(*e_member);
}
*(++a_member) = NULL;
}
}
}
return a_group;
}
/**************************************************************************
* name - atoe_getgrgid
* description -
* parameters -
* returns -
*************************************************************************/
struct group *
atoe_getgrgid(gid_t gid)
{
struct group *e_group;
struct group *a_group = NULL;
e_group = getgrgid(gid);
if (e_group != NULL) {
a_group = e2a_group(e_group);
}
return a_group;
}
/**************************************************************************
* name - atoe_putchar
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_putchar(int ch)
{
return putchar((int)a2e_tab[ch]);
}
/**************************************************************************
* name - atoe_fprintf
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_fprintf(FILE *file, const char *ascii_chars, ...)
{
va_list args;
char buf[BUFLEN];
char *ebuf;
int len;
va_start(args,ascii_chars);
len = atoe_vsnprintf(buf,BUFLEN,ascii_chars,args);
/* Abort if failed... */
if (len == -1) return len;
ebuf = a2e(buf,len);
#pragma convlit(suspend)
len = fprintf(file,"%s", ebuf);
#pragma convlit(resume)
free(ebuf);
va_end(args);
return len;
}
/**************************************************************************
* name - atoe_printf
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_printf( const char *ascii_chars, ...)
{
va_list args;
char buf[BUFLEN];
char *ebuf;
int len;
va_start(args,ascii_chars);
len = atoe_vsnprintf(buf,BUFLEN,ascii_chars,args);
/* Abort if failed... */
if (len==-1) return len;
ebuf = a2e(buf,len);
#pragma convlit(suspend)
len = printf("%s", ebuf);
#pragma convlit(resume)
free(ebuf);
va_end(args);
return len;
}
/*************************************************************************
* name - std_sprintf
* description -
* This function does not need to convert ascii -> EBCDIC
* as there is no IO
* parameters -
* returns -
*************************************************************************/
int
std_sprintf( const char *buf, char *ascii_chars, ...)
{
int len;
va_list args;
va_start(args,ascii_chars);
len = sprintf((char *)buf, ascii_chars,args);
va_end(args);
return len;
}
/**************************************************************************
* name - atoe_sprintf
* description -
* This function does not need to convert ascii -> EBCDIC
* as there is no IO
* parameters -
* returns -
*************************************************************************/
int
atoe_sprintf( const char *buf, char *ascii_chars, ...)
{
int len;
char wrkbuf[BUFLEN];
va_list args;
va_start(args,ascii_chars);
len = atoe_vsnprintf(wrkbuf,BUFLEN,ascii_chars,args);
va_end(args);
if (-1 == len) return len;
strcpy((char *)buf, wrkbuf);
return len;
}
/**************************************************************************
* name - atoe_vprintf
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_vprintf(const char *ascii_chars, va_list args)
{
return atoe_vfprintf(stdout, ascii_chars, args);
}
/**************************************************************************
* name - atoe_vfprintf
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_vfprintf(FILE *file, const char *ascii_chars, va_list args)
{
char buf[BUFLEN];
char *ebuf;
int len;
len = atoe_vsnprintf(buf,BUFLEN,ascii_chars,args);
if (len == -1) return len;
ebuf = a2e(buf,len);
#pragma convlit(suspend)
len = fprintf(file,"%s", ebuf);
#pragma convlit(resume)
free(ebuf);
return len;
}
/**************************************************************************
* name - atoe_vsprintf
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_vsprintf(char *target, const char *ascii_chars, va_list args)
{
char buf[BUFLEN];
int bsize = 0;
bsize = atoe_vsnprintf(buf,BUFLEN,ascii_chars,args);
if (-1 == bsize) return bsize;
strcpy(target,buf);
return(bsize);
}
/**************************************************************************
* name - atoe_sscanf
* description -
* parameters -
* returns -
* RESTRICTIONS - At the time of writing, there is no requirement to support
* character or string formatting, so I have opted to avoid
* the pain of trawling the format string along with the
* argument list in order to convert characters/strings from
* EBCDIC back to ASCII after calling the RTL sscanf().
*************************************************************************/
int
atoe_sscanf(const char *buffer, const char *format, va_list args)
{
char *e_buffer = a2e_string(buffer);
char *e_format = a2e_string(format);
int len = sscanf((const char *)e_buffer, (const char *)e_format, args);
free(e_buffer);
free(e_format);
return len;
}
/**************************************************************************
* name - atoe_strftime
* description -
* parameters -
* returns -
*************************************************************************/
size_t
atoe_strftime(char *buf, size_t buflen,
const char *format, const struct tm *timeptr)
{
size_t num;
char *e,*a;
e = a2e_string(format);
num = strftime(buf, buflen, e, timeptr);
a = e2a(buf,num);
memcpy(buf,a,num);
free(e);
free(a);
return num;
}
/**************************************************************************
* name - atoe_fwrite
* description -
* parameters -
* returns -
*************************************************************************/
size_t
atoe_fwrite(const void *buffer, size_t size, size_t count, FILE *stream)
{
int numwritten;
char *e;
e = a2e((void *)buffer,size*count);
numwritten = fwrite(e,size,count,stream);
free(e);
return numwritten;
}
/**************************************************************************
* name - atoe_fread
* description -
* parameters -
* returns -
*************************************************************************/
size_t
atoe_fread(void *buffer, size_t size, size_t count, FILE *stream)
{
int numread;
char *a;
numread = fread(buffer,size,count,stream);
a = e2a((char *)buffer,numread);
memcpy(buffer,a,numread);
free(a);
return numread;
}
/**************************************************************************
* name - atoe_system
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_system( char * cmd)
{
char *eb;
int result;
eb = a2e_string(cmd);
result = system(eb) ;
free(eb);
return result;
}
/**************************************************************************
* name - atoe_setlocale
* description -
* parameters -
* returns -
*************************************************************************/
char *
atoe_setlocale(int category, const char *locale)
{
char *eb, *result;
eb = a2e_string(locale);
result = setlocale(category, eb) ;
return e2a_string(result);
}
/**************************************************************************
* name - atoe_ctime
* description -
* parameters -
* returns -
*************************************************************************/
char *
atoe_ctime(const time_t * t_in)
{
char *eb;
eb = ctime(t_in);
return e2a_string(eb);
}
/**************************************************************************
* name - atoe_strtod
* description -
* parameters -
* returns -
*************************************************************************/
double atoe_strtod( char * s, char ** p)
{
char * sebcdic;
char * pebcdic;
double d;
sebcdic = a2e_string(s);
d = strtod(sebcdic,&pebcdic);
if (p != NULL) {
*p = s + (pebcdic - sebcdic);
}
free(sebcdic);
return d;
}
/**************************************************************************
* name - atoe_strtol
* description -
* parameters -
* returns -
*************************************************************************/
int atoe_strtol(const char * s, char ** p, int b)
{
char * sebcdic;
char * pebcdic;
int i;
sebcdic = a2e_string(s);
i = strtol((const char *)sebcdic, &pebcdic, b);
if (p != NULL) {
*p = (char *)s + (pebcdic - sebcdic);
}
free(sebcdic);
return i;
}
/**************************************************************************
* name - atoe_strtoul
* description -
* parameters -
* returns -
*************************************************************************/
unsigned long atoe_strtoul(const char * s, char ** p, int b)
{
char * sebcdic;
char * pebcdic;
unsigned long i;
sebcdic = a2e_string(s);
i = strtoul((const char *)sebcdic, &pebcdic, b);
if (p != NULL) {
*p = (char *)s + (pebcdic - sebcdic);
}
free(sebcdic);
return i;
}
/**************************************************************************
* name - atoe_strtoull
* description -
* parameters -
* returns -
*************************************************************************/
unsigned long long atoe_strtoull(const char * s, char ** p, int b)
{
char * sebcdic;
char * pebcdic;
unsigned long long i;
sebcdic = a2e_string(s);
i = strtoull((const char *)sebcdic, &pebcdic, b);
if (p != NULL) {
*p = (char *)s + (pebcdic - sebcdic);
}
free(sebcdic);
return i;
}
/*************************************************************************
* name - atoe_atof
* description -
* parameters -
* returns -
*************************************************************************/
double
atoe_atof(char * ascii_string)
{
double rc;
char * ebcdic_string;
ebcdic_string = a2e_string(ascii_string);
rc = atof(ebcdic_string);
free(ebcdic_string);
return rc;
}
/**************************************************************************
* name - atoe_atoi
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_atoi(char * ascii_string)
{
int rc;
char * ebcdic_string;
ebcdic_string = a2e_string(ascii_string);
rc = atoi(ebcdic_string);
free(ebcdic_string);
return rc;
}
/*************************************************************************
* name - atoe_atol
* description -
* parameters -
* returns -
*************************************************************************/
long
atoe_atol(char * ascii_string)
{
long rc;
char * ebcdic_string;
ebcdic_string = a2e_string(ascii_string);
rc = atol(ebcdic_string);
free(ebcdic_string);
return rc;
}
/**************************************************************************
* name - atoe_gethostname
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_gethostname(char *name, int namelen)
{
int rc = gethostname(name, namelen);
char *ascii_name = e2a(name, namelen);
strcpy(name, ascii_name);
free(ascii_name);
return rc;
}
/**************************************************************************
* name - atoe_gethostbyname
* description -
* parameters -
* returns -
*************************************************************************/
#define HOSTBYNAME_CACHE_SIZE 50
typedef struct hostbyname_t {
char *hostname;
struct hostent h;
} hostbyname_t;
static hostbyname_t hostbyname_cache[HOSTBYNAME_CACHE_SIZE];
static int hostbyname_cache_next = 0;
static pthread_mutex_t hostbyname_mutex = PTHREAD_MUTEX_INITIALIZER;
static int hostbyname_initialized = 0;
struct hostent*
atoe_gethostbyname(const char *hostname) {
char *h;
struct hostent *hostptr = NULL, *hostptr_a = NULL;
int index;
pthread_mutex_lock(&hostbyname_mutex);
if (0 == hostbyname_initialized) {
/* initialize cache in static storage */
for (index=0; index<HOSTBYNAME_CACHE_SIZE; index++) {
hostbyname_cache[index].hostname = NULL;
memset(&hostbyname_cache[index].h, 0, sizeof(struct hostent));
}
hostbyname_initialized = 1;
}
/* see if we are already using a cache entry for this hostname */
for (index=0;
index<HOSTBYNAME_CACHE_SIZE, hostbyname_cache[index].hostname!=NULL;
index++) {
if (0 == strcmp(hostname, hostbyname_cache[index].hostname)) {
hostptr_a = &hostbyname_cache[index].h;
break;
}
}
if (NULL == hostptr_a) {
/* use next cache slot for this hostname */
if (hostbyname_cache[hostbyname_cache_next].hostname) {
free(hostbyname_cache[hostbyname_cache_next].hostname);
}
hostbyname_cache[hostbyname_cache_next].hostname = strdup(hostname);
if (!hostbyname_cache[hostbyname_cache_next].hostname) {
pthread_mutex_unlock(&hostbyname_mutex);
return NULL;
}
hostptr_a = &hostbyname_cache[hostbyname_cache_next].h;
if (++hostbyname_cache_next == HOSTBYNAME_CACHE_SIZE) {
hostbyname_cache_next = 0;
}
}
/* convert the input hostname to ebcdic */
h = a2e_string(hostname);
/* and issue the system call */
hostptr = gethostbyname(h);
/* don't need the ebcdic copy of hostname any more */
free(h);
/* if the system call worked save the results, otherwise return NULL */
if (hostptr) {
/* if we're re-using a cache slot, free any previously saved name */
if (hostptr_a->h_name) {
free(hostptr_a->h_name);
}
/* copy the system returned hostent into our cache */
memcpy(hostptr_a, hostptr, sizeof(struct hostent));
/* convert the system returned name to ascii and save it in our cache */
hostptr_a->h_name = e2a_string(hostptr->h_name);
/* if everything worked return the address of the cache entry */
if (hostptr_a->h_name) {
hostptr = hostptr_a;
} else {
hostptr = NULL;
}
}
pthread_mutex_unlock(&hostbyname_mutex);
return hostptr;
}
/**************************************************************************
* name - atoe_gethostbyname_r
* description -
* parameters -
* returns -
*************************************************************************/
struct hostent*
atoe_gethostbyname_r(char *hostname, struct hostent *hentptr,
char *buf, int bufsize, int *h_error) {
char *h, *h_n;
struct hostent *hostptr;
h = a2e_string(hostname);
if ((hostptr = gethostbyname(h)) == NULL) {
hentptr = NULL;
} else if ((strlen(hostptr->h_name) + 1) > bufsize) {
*h_error = errno = ERANGE;
hentptr = NULL;
} else {
memcpy(hentptr, hostptr, sizeof(struct hostent));
h_n = e2a_string(hostptr->h_name);
strcpy(buf, h_n);
free(h_n);
hentptr->h_name = buf;
}
free(h);
return hentptr;
}
/**************************************************************************
* name - atoe_gethostbyaddr
* description -
* parameters -
* returns -
*************************************************************************/
struct hostent*
atoe_gethostbyaddr(const void *address, int addrlen, int domain,
struct hostent *hentptr, char *buf, int bufsize,
int *h_error) {
char *h_n;
struct hostent *hostptr;
if ((hostptr = gethostbyaddr(address,addrlen,domain)) == NULL){
hentptr = NULL;
} else if ((strlen(hostptr->h_name) + 1) > bufsize) {
*h_error = errno = ERANGE;
hentptr = NULL;
} else {
memcpy(hentptr, hostptr, sizeof(struct hostent));
h_n = e2a_string(hostptr->h_name);
strcpy(buf, h_n);
free(h_n);
hentptr->h_name = buf;
}
return hentptr;
}
/**************************************************************************
* name - atoe_getprotobyname
* description -
* parameters -
* returns -
*************************************************************************/
struct protoent *
atoe_getprotobyname(const char *name) {
struct protoent *pent;
char *e_name, *p_n;
e_name = a2e_string((char *)name);
if ((pent = getprotobyname(e_name)) != 0) {
p_n = e2a_string(pent->p_name);
pent->p_name = p_n;
}
free(e_name);
return pent;
}
/**************************************************************************
* name - atoe_inet_addr
* description -
* parameters -
* returns -
*************************************************************************/
unsigned long
atoe_inet_addr(char *hostname)
{
unsigned long iaddr = -1;
char *h = a2e_string(hostname);
iaddr = inet_addr(h);
free(h);
return iaddr;
}
#define _ISALNUM_ASCII 0x0001
#define _ISALPHA_ASCII 0x0002
#define _ISCNTRL_ASCII 0x0004
#define _ISDIGIT_ASCII 0x0008
#define _ISGRAPH_ASCII 0x0010
#define _ISLOWER_ASCII 0x0020
#define _ISPRINT_ASCII 0x0040
#define _ISPUNCT_ASCII 0x0080
#define _ISSPACE_ASCII 0x0100
#define _ISUPPER_ASCII 0x0200
#define _ISXDIGIT_ASCII 0x0400
#define _XUPPER_ASCII 0xdf
#define _XLOWER_ASCII 0x20
/* Check for iconv_init() already done */
int iconv_initialised = 0;
/* Table for integer test macros */
int _ascii_is_tab[CONV_TABLE_SIZE];
#pragma convlit(suspend)
/**************************************************************************
* name - iconv_init
* description -
* Allocate code conversion descriptors for iconv()
* and build translate tables.
* parameters -
* returns -
*************************************************************************/
int
iconv_init(void)
{
char *asciiSet = "ISO8859-1";
char *defaultSet = "IBM-1047";
char *ebcdicSet, *inptr, *outptr;
size_t inleft, outleft;
iconv_t atoe_cd = (iconv_t)(-1);
iconv_t etoa_cd = (iconv_t)(-1);
char init_tab[CONV_TABLE_SIZE];
int i;
/* Need to save start locale setting */
char *slc = NULL;
/* Get the current locale setting */
char *clc = setlocale(LC_ALL, NULL);
if (iconv_initialised) {
return 0;
}
/*
* Test whether we're running with an DBCS codepage
* If so, use default IBM-1047 EBCDIC SBCS codepage to build translate table.
*/
{
char a[] = {97,0}; /* ASCII "a" */
/* Copy the start locale setting to reset it later */
slc = strdup(clc);
if ( !slc ) return -1;
/* Set the locale to whatever is set by the env. vars */
setlocale(LC_ALL, "") ;
if (( __atoe(a) < 1) && (errno == EINVAL)) {
/* The current locale does not describe a single-byte character set.*/
/* This test does not always give the correct result*/
ebcdicSet = defaultSet;
} else {
char *encoding = NULL;
char *lc;
char *p;
int i;
lc = getenv("LC_ALL");
if (lc == NULL) {
lc = getenv("LC_CTYPE");
if (lc == NULL) {
lc = getenv("LANG");
}
}
if (lc != NULL) {
/* We now have a string with the format
* language_region.encoding@variant any part of which
* may be missing. We need to extract the encoding part
*/
lc = strdup(lc);
if ((p = strchr(lc, '.')) != NULL) {
encoding = p+1;
}
if ((p = strchr(lc, '@')) != NULL) {
*p = '\0';
}
}
lc = encoding;
/* If lc is still NULL or we have "C" encoding
* use the default encoding.
*/
if (lc == NULL || !strcmp(lc, "C")) {
ebcdicSet = defaultSet;
} else {
ebcdicSet = lc;
}
}
}
/* reset the locale to start setting */
clc = setlocale(LC_ALL, slc );
free( slc );
if (((etoa_cd = iconv_open(asciiSet, ebcdicSet)) == (iconv_t)(-1)) ||
((atoe_cd = iconv_open(ebcdicSet, asciiSet)) == (iconv_t)(-1))) {
/* Retry with default ebcdicSet */
if (strcmp(ebcdicSet,defaultSet) == 0) {
return -1;
}
/* Close conversion descriptors just in case one of them succeeded */
if (etoa_cd != (iconv_t)(-1)) {
iconv_close(etoa_cd);
}
if (atoe_cd != (iconv_t)(-1)) {
iconv_close(atoe_cd);
}
if (((etoa_cd = iconv_open(asciiSet, defaultSet)) == (iconv_t)(-1)) ||
((atoe_cd = iconv_open(defaultSet, asciiSet)) == (iconv_t)(-1))) {
return -1;
}
}
/* Build initial table x'00' - x'ff' */
for (i = 0; i < CONV_TABLE_SIZE; i++) {
init_tab[i] = i;
}
/* Create conversion table for ASCII=>EBCDIC */
inptr = init_tab;
outptr = a2e_tab;
inleft = outleft = CONV_TABLE_SIZE;
if (iconv(atoe_cd, &inptr, &inleft, &outptr, &outleft) == -1) {
/* atoe conversion failed */
if (errno == E2BIG) {
/* The EBCDIC codepage is probably DBCS */
/* Close conversion descriptors */
iconv_close(atoe_cd);
iconv_close(etoa_cd);
/* Retry with default IBM-1047 */
if (((etoa_cd = iconv_open(asciiSet, defaultSet)) == (iconv_t)(-1)) ||
((atoe_cd = iconv_open(defaultSet, asciiSet)) == (iconv_t)(-1))) {
return -1;
}
inptr = init_tab;
outptr = a2e_tab;
inleft = outleft = CONV_TABLE_SIZE;
if (iconv(atoe_cd, &inptr, &inleft, &outptr, &outleft) == -1) {
return -1;
}
}
}
/* Create conversion table for EBCDIC=>ASCII */
inptr = init_tab;
outptr = e2a_tab;
inleft = outleft = CONV_TABLE_SIZE;
/* Try to create a complete translate table for this codepage */
/* if an EILSEQ return is received for a codepoint bypass and */
/* move on to the next one. */
while (inleft>0) {
size_t ret;
ret = iconv(etoa_cd, &inptr, &inleft, &outptr, &outleft);
if (ret != (size_t)-1) break;
if (errno == EILSEQ) {
inptr += 1;
inleft -= 1;
outptr += 1;
outleft -= 1;
}
else {
/* etoa conversion failed */
return -1;
}
}
/* Close conversion descriptors */
iconv_close(atoe_cd);
iconv_close(etoa_cd);
/* Build integer test macros flag table */
for (i = 0; i < CONV_TABLE_SIZE; i++) {
_ascii_is_tab[i] = 0;
if (isalnum(a2e_tab[i])) _ascii_is_tab[i] |= _ISALNUM_ASCII;
if (isalpha(a2e_tab[i])) _ascii_is_tab[i] |= _ISALPHA_ASCII;
if (iscntrl(a2e_tab[i])) _ascii_is_tab[i] |= _ISCNTRL_ASCII;
if (isdigit(a2e_tab[i])) _ascii_is_tab[i] |= _ISDIGIT_ASCII;
if (isgraph(a2e_tab[i])) _ascii_is_tab[i] |= _ISGRAPH_ASCII;
if (islower(a2e_tab[i])) _ascii_is_tab[i] |= _ISLOWER_ASCII;
if (isprint(a2e_tab[i])) _ascii_is_tab[i] |= _ISPRINT_ASCII;
if (ispunct(a2e_tab[i])) _ascii_is_tab[i] |= _ISPUNCT_ASCII;
if (isspace(a2e_tab[i])) _ascii_is_tab[i] |= _ISSPACE_ASCII;
if (isupper(a2e_tab[i])) _ascii_is_tab[i] |= _ISUPPER_ASCII;
if (isxdigit(a2e_tab[i])) _ascii_is_tab[i] |= _ISXDIGIT_ASCII;
}
/* If we get here, then we are initialised. */
iconv_initialised = 1;
return 0;
}
#pragma convlit(resume)
/**************************************************************************
* name - atoe_dlopen
* description - Load the DLL specified in dllName by converting it to EBCDIC,
* then calling the system dlopen
* parameters - dllName the DLL name
* mode describes the mode by which the DLL will be loaded
* returns - a handle to the loaded DLL if successful, NULL otherwise
*************************************************************************/
void*
atoe_dlopen(const char * dllName, int mode)
{
void *handle;
char *d = a2e_string(dllName);
handle = dlopen(d, mode);
free(d);
return handle;
}
void *
atoe_dlsym(void *descriptor, const char *name)
{
void *address;
char *ebcdicName = a2e_string(name);
address = dlsym(descriptor, ebcdicName);
free(ebcdicName);
return address;
}
/**************************************************************************
* name - atoe_dllload
* description -
* parameters -
* returns -
*************************************************************************/
dllhandle*
atoe_dllload(char * dllName)
{
dllhandle *handle;
char *d = a2e_string(dllName);
handle = dllload(d);
free(d);
return handle;
}
void *atoe_dllqueryvar(dllhandle* dllHandle, char* varName)
{
char *n = a2e_string(varName);
void *r = dllqueryvar(dllHandle, n);
free(n);
return r;
}
void (*
atoe_dllqueryfn(dllhandle* dllHandle, char* funcName)) ()
{
char *n = a2e_string(funcName);
void (*r)() = dllqueryfn(dllHandle, n);
free(n);
return r;
}
/**************************************************************************
* name - atoe_execv
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_execv (const char *path, char *const argv[])
{
char *ebcdicPath = a2e_string(path);
char **ebcdicArgv;
int size = 0, i, rc;
/* Calculate the size of argv. argv always ends with a null pointer. */
while (*(argv+size)) {
size++;
}
/* Allocate space for the new array and populate */
ebcdicArgv = (char**) malloc(size+1);
for (i=0; i<size; i++) {
*(ebcdicArgv+i) = strdup(a2e_string(argv[i]));
}
/* Null terminate the new array */
*(ebcdicArgv+size) = NULL;
rc = execv(ebcdicPath, ebcdicArgv);
return rc;
}
/**************************************************************************
* name - atoe_execvp
* description -
* parameters -
* returns -
*************************************************************************/
int
atoe_execvp (const char *file, char *const argv[])
{
char *ebcdicFile = a2e_string(file);
char **ebcdicArgv;
int size = 0, i, rc;
/* Calculate the size of argv. argv always ends with a null pointer. */
while (*(argv+size)) {
size++;
}
/* Allocate space for the new array and populate */
ebcdicArgv = (char**) malloc(size+1);
for (i=0; i<size; i++) {
*(ebcdicArgv+i) = strdup(a2e_string(argv[i]));
}
/* Null terminate the new array */
*(ebcdicArgv+size) = NULL;
rc = execvp(ebcdicFile, ebcdicArgv);
return rc;
}
/**************************************************************************
* name - etoa_uname
* description -
* parameters -
* returns -
*************************************************************************/
int
etoa_uname(struct utsname *a) {
struct utsname e;
int rc = 0;
rc = uname(&e);
if (rc == 0 && a != NULL) {
char *temp = NULL;
temp = e2a_string(e.sysname);
strcpy(a->sysname,temp);
free(temp);
temp = e2a_string(e.nodename);
strcpy(a->nodename,temp);
free(temp);
temp = e2a_string(e.release);
strcpy(a->release,temp);
free(temp);
temp = e2a_string(e.version);
strcpy(a->version,temp);
free(temp);
temp = e2a_string(e.machine);
strcpy(a->machine,temp);
free(temp);
}
return rc;
}
/**************************************************************************
* name - etoa_nl_langinfo
* description -
* parameters -
* returns -
*************************************************************************/
char *
etoa_nl_langinfo(int nl_item) {
char *retVal = NULL;
retVal = nl_langinfo(nl_item);
return(retVal != NULL) ? e2a_string(retVal) : NULL;
}
/*********************************************************************/
/* name - atoe_utimes */
/* */
/* description - provide a version of the utimes() system function */
/* that converts the specified path from an ascii to */
/* an ebcdic string. */
/* */
/* parameters - path: ascii string representing the path name */
/* times: times to be used in setting the modification */
/* times of the specified file */
/* */
/* returns - int: 0 (success) or -1 (failure) */
/*********************************************************************/
int atoe_utimes(const char *path, const struct timeval *times)
{
char *ep;
ep = a2e_string(path);
return utimes(ep, times);
}
/*********************************************************************/
/* name - atoe_utime */
/* */
/* description - provide a version of the utime() system function */
/* that converts the specified path from an ascii to */
/* an ebcdic string. */
/* */
/* parameters - path: ascii string representing the path name */
/* buf: times to be used in setting the modification */
/* and access times of the specified file */
/* */
/* returns - int: 0 (success) or -1 (failure) */
/*********************************************************************/
int atoe_utime(const char *path, const struct utimebuf *buf)
{
char *ep;
ep = a2e_string(path);
return utime(ep, buf);
}
/*********************************************************************/
/* name - atoe_chmod */
/* */
/* description - provide a version of the chmod() system function */
/* that converts the specified path from an ascii to */
/* an ebcdic string. */
/* */
/* parameters - path: ascii string representing the path name */
/* mode: bit set representing mode to be set on the */
/* specified file */
/* */
/* returns - int: 0 (success) or -1 (failure) */
/*********************************************************************/
int atoe_chmod(const char *path, mode_t mode)
{
char *ep;
ep = a2e_string(path);
return chmod(ep, mode);
}
/*********************************************************************/
/* name - atoe_chdir */
/* */
/* description - provide a version of the chdir() system function */
/* that converts the specified path from an ascii to */
/* an ebcdic string. */
/* */
/* parameters - path: ascii string representing the path name */
/* */
/* returns - int: 0 (success) or -1 (failure) */
/*********************************************************************/
int atoe_chdir(const char *path)
{
int rc;
char *ep;
ep = a2e_string(path);
rc = chdir(ep);
free(ep);
return rc;
}
/*********************************************************************/
/* name - atoe_chown */
/* */
/* description - provide a version of the chown() system function */
/* that converts the specified path from an ascii to */
/* an ebcdic string. */
/* */
/* parameters - path: ascii string representing the path name */
/* uid: new user id (-1 for no change) */
/* gid: new group id (-1 for no change) */
/* */
/* returns - int: 0 (success) or -1 (failure) */
/*********************************************************************/
int atoe_chown(const char *path, uid_t uid, gid_t gid)
{
int rc;
char *ep;
ep = a2e_string(path);
rc = chown(ep, uid, gid);
free(ep);
return rc;
}
/**************************************************************************
* name - atoe_ftok
* description -
* parameters -
* returns -
*************************************************************************/
key_t atoe_ftok(const char *pathname, int id)
{
key_t key;
char *e;
e = a2e_string(pathname);
key = ftok(e, id);
free(e);
return key;
}
/**************************************************************************
* name - etoa___osname
* description -
* parameters -
* returns -
*************************************************************************/
int
etoa___osname(struct utsname *a) {
struct utsname e;
int rc = 0;
rc = __osname(&e);
if (rc == 0 && a != NULL) {
char *temp = NULL;
temp = e2a_string(e.sysname);
strcpy(a->sysname,temp);
free(temp);
temp = e2a_string(e.nodename);
strcpy(a->nodename,temp);
free(temp);
temp = e2a_string(e.release);
strcpy(a->release,temp);
free(temp);
temp = e2a_string(e.version);
strcpy(a->version,temp);
free(temp);
temp = e2a_string(e.machine);
strcpy(a->machine,temp);
free(temp);
}
return rc;
}
/* END OF FILE */