/* Copies "from" to "to". Note that the functionality here is similar
to the win32 function CopyFile, but (1) we copy LastAccessTime and
CopyFile doesn't, (2) we set file attributes to the default set by
the C library and CopyFile copies them. Neither #1 nor #2 was intentional
as far as I know, but changing them could be confusing, unless there
is some reason they should be changed (this would need more
investigation). */
int copy_file (const char *from, const char *to, int force_overwrite, int must_exist)
{
struct stat sb;
struct utimbuf t;
int fdin, fdout;
#ifdef UTIME_EXPECTS_WRITABLE
int change_it_back = 0;
#endif
TRACE(1,"copy(%s,%s)",from,to);
if (noexec)
return 0;
if ((fdin = open (from, O_RDONLY | O_BINARY,0)) < 0)
{
if(must_exist)
error (1, errno, "cannot open %s for copying", from);
else
return -1;
}
if (fstat (fdin, &sb) < 0)
{
if(must_exist)
error (1, errno, "cannot fstat %s", from);
else
{
close(fdin);
return -1;
}
}
if (force_overwrite && unlink_file (to) && !existence_error (errno))
error (1, errno, "unable to remove %s", to);
if ((fdout = open (to, O_CREAT | O_TRUNC | O_RDWR | O_BINARY, 0600)) < 0)
error (1, errno, "cannot create %s for copying", to);
if (sb.st_size > 0)
{
char buf[BUFSIZ];
int n;
for (;;)
{
n = read (fdin, buf, sizeof(buf));
if (n == -1)
{
#ifdef EINTR
if (errno == EINTR)
continue;
#endif
error (1, errno, "cannot read file %s for copying", from);
}
else if (n == 0)
break;
if (write(fdout, buf, n) != n) {
error (1, errno, "cannot write file %s for copying", to);
}
}
#ifdef HAVE_FSYNC
if (fsync (fdout))
error (1, errno, "cannot fsync file %s after copying", to);
#endif
}
if (close (fdin) < 0)
error (0, errno, "cannot close %s", from);
if (close (fdout) < 0)
error (1, errno, "cannot close %s", to);
#ifdef UTIME_EXPECTS_WRITABLE
if (!iswritable (to))
{
xchmod (to, 1);
change_it_back = 1;
}
#endif /* UTIME_EXPECTS_WRITABLE */
/* now, set the times for the copied file to match those of the original */
memset ((char *) &t, 0, sizeof (t));
t.actime = sb.st_atime;
t.modtime = sb.st_mtime;
utime (to, &t);
chmod(to,sb.st_mode);
#ifdef UTIME_EXPECTS_WRITABLE
if (change_it_back)
xchmod (to, 0);
#endif /* UTIME_EXPECTS_WRITABLE */
return 0;
}
/*
* Copies "from" to "to", decompressing "from" on the fly
*/
int copy_and_unzip_file (const char *from, const char *to, int force_overwrite, int must_exist)
{
struct stat sb;
struct utimbuf t;
int fdin, fdout;
z_stream zstr = {0};
int zstatus;
char buf[BUFSIZ*10];
char zbuf[BUFSIZ*20];
int n;
#ifdef UTIME_EXPECTS_WRITABLE
int change_it_back = 0;
#endif
TRACE(1,"copy_and_unzip(%s,%s)",from,to);
if (noexec)
return 0;
if ((fdin = open (from, O_RDONLY | O_BINARY,0)) < 0)
{
if(must_exist)
error (1, errno, "cannot open %s for copying", from);
else
return -1;
}
if (fstat (fdin, &sb) < 0)
{
if(must_exist)
error (1, errno, "cannot fstat %s", from);
else
{
close(fdin);
return -1;
}
}
if (force_overwrite && unlink_file (to) && !existence_error (errno))
error (1, errno, "unable to remove %s", to);
if ((fdout = open (to, O_CREAT | O_TRUNC | O_RDWR | O_BINARY, 0600))<0)
error (1, errno, "cannot create %s for copying", to);
zstatus = inflateInit2 (&zstr, 47);
if(zstatus != Z_OK)
error(1, 0, "expansion error (INIT): (%d)%s", zstatus,zstr.msg);
if (sb.st_size > 0)
{
for (;;)
{
n = read (fdin, buf, sizeof(buf));
if (n == -1)
{
#ifdef EINTR
if (errno == EINTR)
continue;
#endif
error (1, errno, "cannot read file %s for copying", from);
}
else if (n == 0)
break;
zstr.next_in = buf;
zstr.avail_in = n;
while(zstr.avail_in)
{
zstr.next_out = zbuf;
zstr.avail_out = sizeof(zbuf);
zstatus = inflate (&zstr, 0);
if(zstatus != Z_OK && zstatus != Z_STREAM_END)
error(1,0, "expansion error (inflate): (%d)%s", zstatus,zstr.msg);
n = sizeof(zbuf)-zstr.avail_out;
if (n && write(fdout, zbuf, n) != n) {
error (1, errno, "cannot write file %s for copying", to);
}
}
if(zstatus == Z_STREAM_END)
break;
}
#ifdef HAVE_FSYNC
if (fsync (fdout))
error (1, errno, "cannot fsync file %s after copying", to);
#endif
}
zstr.next_out = zbuf;
zstr.avail_out = sizeof(zbuf);
zstatus = inflate (&zstr, Z_FINISH);
if(zstatus != Z_OK && zstatus != Z_STREAM_END)
error(1,0, "expansion error (Z_FINISH): (%d)%s", zstatus,zstr.msg);
n = sizeof(zbuf)-zstr.avail_out;
if (n && write(fdout, zbuf, n) != n) {
error (1, errno, "cannot write file %s for copying", to);
}
zstr.next_in = buf;
zstr.avail_in = 0;
zstr.next_out = zbuf;
zstr.avail_out = sizeof(zbuf);
zstatus = inflateEnd(&zstr);
if(zstatus != Z_OK)
error(1,0, "expansion error: %s", zstr.msg);
if (close (fdin) < 0)
error (0, errno, "cannot close %s", from);
if (close (fdout) < 0)
error (1, errno, "cannot close %s", to);
#ifdef UTIME_EXPECTS_WRITABLE
if (!iswritable (to))
{
xchmod (to, 1);
change_it_back = 1;
}
#endif /* UTIME_EXPECTS_WRITABLE */
/* now, set the times for the copied file to match those of the original */
memset ((char *) &t, 0, sizeof (t));
t.actime = sb.st_atime;
t.modtime = sb.st_mtime;
utime (to, &t);
chmod(to,sb.st_mode);
#ifdef UTIME_EXPECTS_WRITABLE
if (change_it_back)
xchmod (to, 0);
#endif /* UTIME_EXPECTS_WRITABLE */
return 0;
}
/* Fill in and return a Vers_TS structure for the file FINFO.
*
* INPUTS
* finfo struct file_info data about the file to be examined.
* options Keyword expansion options, I think generally from the
* command line. Can be either NULL or "" to indicate
* none are specified here.
* tag Tag specified by user on the command line (via -r).
* date Date specified by user on the command line (via -D).
* force_tag_match If set and TAG is specified, will only set RET->vn_rcs
* based on TAG. Otherwise, if TAG is specified and does
* not exist in the file, RET->vn_rcs will be set to the
* head revision.
* set_time If set, set the last modification time of the user file
* specified by FINFO to the checkin time of RET->vn_rcs.
*
* RETURNS
* Vers_TS structure for FINFO.
*/
Vers_TS *
Version_TS (struct file_info *finfo, char *options, char *tag, char *date,
int force_tag_match, int set_time)
{
Node *p;
RCSNode *rcsdata;
Vers_TS *vers_ts;
struct stickydirtag *sdtp;
Entnode *entdata;
char *rcsexpand = NULL;
/* get a new Vers_TS struct */
vers_ts = xmalloc (sizeof (Vers_TS));
memset (vers_ts, 0, sizeof (*vers_ts));
/*
* look up the entries file entry and fill in the version and timestamp
* if entries is NULL, there is no entries file so don't bother trying to
* look it up (used by checkout -P)
*/
if (finfo->entries == NULL)
{
sdtp = NULL;
p = NULL;
}
else
{
p = findnode_fn (finfo->entries, finfo->file);
sdtp = finfo->entries->list->data; /* list-private */
}
if (p == NULL)
{
entdata = NULL;
}
else
{
entdata = p->data;
if (entdata->type == ENT_SUBDIR)
{
/* According to cvs.texinfo, the various fields in the Entries
file for a directory (other than the name) do not have a
defined meaning. We need to pass them along without getting
confused based on what is in them. Therefore we make sure
not to set vn_user and the like from Entries, add.c and
perhaps other code will expect these fields to be NULL for
a directory. */
vers_ts->entdata = entdata;
}
else
#ifdef SERVER_SUPPORT
/* An entries line with "D" in the timestamp indicates that the
client sent Is-modified without sending Entry. So we want to
use the entries line for the sole purpose of telling
time_stamp_server what is up; we don't want the rest of CVS
to think there is an entries line. */
if (strcmp (entdata->timestamp, "D") != 0)
#endif
{
vers_ts->vn_user = xstrdup (entdata->version);
vers_ts->ts_rcs = xstrdup (entdata->timestamp);
vers_ts->ts_conflict = xstrdup (entdata->conflict);
if (!(tag || date) && !(sdtp && sdtp->aflag))
{
vers_ts->tag = xstrdup (entdata->tag);
vers_ts->date = xstrdup (entdata->date);
}
vers_ts->entdata = entdata;
}
/* Even if we don't have an "entries line" as such
(vers_ts->entdata), we want to pick up options which could
have been from a Kopt protocol request. */
if (!options || *options == '\0')
{
if (!(sdtp && sdtp->aflag))
vers_ts->options = xstrdup (entdata->options);
}
}
/* Always look up the RCS keyword mode when we have an RCS archive. It
* will either be needed as a default or to avoid allowing the -k options
* specified on the command line from overriding binary mode (-kb).
*/
if (finfo->rcs != NULL)
rcsexpand = RCS_getexpand (finfo->rcs);
/*
* -k options specified on the command line override (and overwrite)
* options stored in the entries file and default options from the RCS
* archive, except for binary mode (-kb).
*/
if (options && *options != '\0')
{
if (vers_ts->options != NULL)
free (vers_ts->options);
if (rcsexpand != NULL && strcmp (rcsexpand, "b") == 0)
vers_ts->options = xstrdup ("-kb");
else
vers_ts->options = xstrdup (options);
}
else if ((!vers_ts->options || *vers_ts->options == '\0')
&& rcsexpand != NULL)
{
/* If no keyword expansion was specified on command line,
use whatever was in the rcs file (if there is one). This
is how we, if we are the server, tell the client whether
a file is binary. */
if (vers_ts->options != NULL)
free (vers_ts->options);
vers_ts->options = xmalloc (strlen (rcsexpand) + 3);
strcpy (vers_ts->options, "-k");
strcat (vers_ts->options, rcsexpand);
}
if (!vers_ts->options)
vers_ts->options = xstrdup ("");
/*
* if tags were specified on the command line, they override what is in
* the Entries file
*/
if (tag || date)
{
vers_ts->tag = xstrdup (tag);
vers_ts->date = xstrdup (date);
}
else if (!vers_ts->entdata && (sdtp && sdtp->aflag == 0))
{
if (!vers_ts->tag)
{
vers_ts->tag = xstrdup (sdtp->tag);
vers_ts->nonbranch = sdtp->nonbranch;
}
if (!vers_ts->date)
vers_ts->date = xstrdup (sdtp->date);
}
/* Now look up the info on the source controlled file */
if (finfo->rcs != NULL)
{
rcsdata = finfo->rcs;
rcsdata->refcount++;
}
else if (finfo->repository != NULL)
rcsdata = RCS_parse (finfo->file, finfo->repository);
else
rcsdata = NULL;
if (rcsdata != NULL)
{
/* squirrel away the rcsdata pointer for others */
vers_ts->srcfile = rcsdata;
if (vers_ts->tag && strcmp (vers_ts->tag, TAG_BASE) == 0)
{
vers_ts->vn_rcs = xstrdup (vers_ts->vn_user);
vers_ts->vn_tag = xstrdup (vers_ts->vn_user);
}
else
{
int simple;
vers_ts->vn_rcs = RCS_getversion (rcsdata, vers_ts->tag,
vers_ts->date, force_tag_match,
&simple);
if (vers_ts->vn_rcs == NULL)
vers_ts->vn_tag = NULL;
else if (simple)
vers_ts->vn_tag = xstrdup (vers_ts->tag);
else
vers_ts->vn_tag = xstrdup (vers_ts->vn_rcs);
}
/*
* If the source control file exists and has the requested revision,
* get the Date the revision was checked in. If "user" exists, set
* its mtime.
*/
if (set_time && vers_ts->vn_rcs != NULL)
{
#ifdef SERVER_SUPPORT
if (server_active)
server_modtime (finfo, vers_ts);
else
#endif
{
struct utimbuf t;
memset (&t, 0, sizeof (t));
t.modtime = RCS_getrevtime (rcsdata, vers_ts->vn_rcs, 0, 0);
if (t.modtime != (time_t) -1)
{
#ifdef UTIME_EXPECTS_WRITABLE
int change_it_back = 0;
#endif
(void) time (&t.actime);
#ifdef UTIME_EXPECTS_WRITABLE
if (!iswritable (finfo->file))
{
xchmod (finfo->file, 1);
change_it_back = 1;
}
#endif /* UTIME_EXPECTS_WRITABLE */
/* This used to need to ignore existence_errors
(for cases like where update.c now clears
set_time if noexec, but didn't used to). I
think maybe now it doesn't (server_modtime does
not like those kinds of cases). */
(void) utime (finfo->file, &t);
#ifdef UTIME_EXPECTS_WRITABLE
if (change_it_back)
xchmod (finfo->file, 0);
#endif /* UTIME_EXPECTS_WRITABLE */
}
}
}
}
/* get user file time-stamp in ts_user */
if (finfo->entries != NULL)
{
#ifdef SERVER_SUPPORT
if (server_active)
time_stamp_server (finfo->file, vers_ts, entdata);
else
#endif
vers_ts->ts_user = time_stamp (finfo->file);
}
return (vers_ts);
}
/* Functions */
int
select (int fds, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *timeout)
{
fd_set oread, owrite, oexcept;
int ticks, start;
int nfds;
if (fds > _POSIX_FD_SETSIZE)
{
errno = EINVAL;
return -1;
}
FD_ZERO (&oread);
FD_ZERO (&owrite);
FD_ZERO (&oexcept);
nfds = 0;
ticks = -1;
if (timeout)
{
ticks = timeout->tv_sec * 100 + timeout->tv_usec / 10000;
if (ticks < 0)
{
errno = EINVAL;
return -1;
}
}
start = _iocs_ontime ();
for (;;)
{
{
int fd;
for (fd = 0; fd < fds; fd++)
{
int accmode;
if (_fddb[fd].inuse == _FD_NOTUSED)
continue;
accmode = _fddb[fd].oflag & O_ACCMODE;
if (isatty (fd))
{
if (XFD_ISSET (fd, rfds) && isreadable (accmode) && _dos_k_keysns ())
{
FD_SET (fd, &oread);
nfds++;
}
if (XFD_ISSET (fd, wfds) && iswritable (accmode))
{
FD_SET (fd, &owrite);
nfds++;
}
}
#if 0
else if (_fddb[fd].sockno >= 0)
{
if (XFD_ISSET (fd, rfds) && _socklen (_fddb[fd].sockno, 0))
{
FD_SET (fd, &oread);
nfds++;
}
if (XFD_ISSET (fd, wfds) /* && _socklen (_fddb[fd].sockno, 1) == 0 */)
{
FD_SET (fd, &owrite);
nfds++;
}
}
#endif
else
{
if (XFD_ISSET (fd, rfds) && isreadable (accmode) && _dos_ioctrlis (fd))
{
FD_SET (fd, &oread);
nfds++;
}
if (XFD_ISSET (fd, wfds) && iswritable (accmode) && _dos_ioctrlos (fd))
{
FD_SET (fd, &owrite);
nfds++;
}
}
}
}
{
int rest;
if ((rest = (_iocs_ontime () - start) % 8640000) < 0)
rest += 8640000;
if (nfds != 0)
{
if (ticks >= 0)
{
int left;
if ((left = ticks - rest) < 0)
left = 0;
timeout->tv_sec = left / 100;
timeout->tv_usec = (left % 100) * 10000;
}
if (rfds)
*rfds = oread;
if (wfds)
*wfds = owrite;
if (efds)
*efds = oexcept;
return nfds;
}
if (ticks >= 0 && rest > ticks)
return 0;
}
_dos_change_pr ();
}
}
/*
* Copies "from" to "to".
*/
int copy_file (const char *from, const char *to, int force_overwrite, int must_exist)
{
struct stat sb;
struct utimbuf t;
int fdin, fdout;
#ifdef UTIME_EXPECTS_WRITABLE
int change_it_back = 0;
#endif
TRACE(1,"copy(%s,%s)",PATCH_NULL(from),PATCH_NULL(to));
if (noexec)
return 0;
/* If the file to be copied is a link or a device, then just create
the new link or device appropriately. */
if (islink (from))
{
char *source = xreadlink (from);
symlink (source, to);
xfree (source);
return 0;
}
if (isdevice (from))
{
#if defined(HAVE_MKNOD) && defined(HAVE_STRUCT_STAT_ST_RDEV)
if (stat (from, &sb) < 0)
error (1, errno, "cannot stat %s", fn_root(from));
mknod (to, sb.st_mode, sb.st_rdev);
#else
error (1, 0, "cannot copy device files on this system (%s)", fn_root(from));
#endif
}
else
{
#ifdef MAC_HFS_STUFF
/* Only use the mac specific copying routine in the client, since
the server shouldn't have any need to handle resource forks
(all the resource fork handling is done in the client -
the server only handles flat files) */
if ( !server_active ) {
if (stat (from, &sb) < 0)
{
if(must_exist)
error (1, errno, "cannot stat %s", fn_root(from));
else
return -1;
}
mac_copy_file(from, to, force_overwrite, must_exist);
} else {
#endif
/* Not a link or a device... probably a regular file. */
if ((fdin = CVS_OPEN (from, O_RDONLY)) < 0)
{
if(must_exist)
error (1, errno, "cannot open %s for copying", fn_root(from));
else
return -1;
}
if (fstat (fdin, &sb) < 0)
{
if(must_exist)
error (1, errno, "cannot fstat %s", fn_root(from));
else
{
close(fdin);
return -1;
}
}
if (force_overwrite && unlink_file (to) && !existence_error (errno))
error (1, errno, "unable to remove %s", to);
if ((fdout = creat (to, (int) sb.st_mode & 07777)) < 0)
error (1, errno, "cannot create %s for copying", fn_root(to));
if (sb.st_size > 0)
{
char buf[BUFSIZ];
int n;
for (;;)
{
n = read (fdin, buf, sizeof(buf));
if (n == -1)
{
#ifdef EINTR
if (errno == EINTR)
continue;
#endif
error (1, errno, "cannot read file %s for copying", fn_root(from));
}
else if (n == 0)
break;
if (write(fdout, buf, n) != n) {
error (1, errno, "cannot write file %s for copying", fn_root(to));
}
}
#ifdef HAVE_FSYNC
if (fsync (fdout))
error (1, errno, "cannot fsync file %s after copying", fn_root(to));
#endif
}
if (close (fdin) < 0)
error (0, errno, "cannot close %s", fn_root(from));
if (close (fdout) < 0)
error (1, errno, "cannot close %s", fn_root(to));
#ifdef MAC_HFS_STUFF
}
#endif
}
#ifdef UTIME_EXPECTS_WRITABLE
if (!iswritable (to))
{
xchmod (to, 1);
change_it_back = 1;
}
#endif /* UTIME_EXPECTS_WRITABLE */
/* now, set the times for the copied file to match those of the original */
memset ((char *) &t, 0, sizeof (t));
t.actime = sb.st_atime;
t.modtime = sb.st_mtime;
(void) utime (to, &t);
#ifdef UTIME_EXPECTS_WRITABLE
if (change_it_back)
xchmod (to, 0);
#endif /* UTIME_EXPECTS_WRITABLE */
return 0;
}
/*
* Copies "from" to "to", decompressing "from" on the fly
*/
int copy_and_unzip_file (const char *from, const char *to, int force_overwrite, int must_exist)
{
struct stat sb;
struct utimbuf t;
int fdin, fdout;
z_stream zstr = {0};
int zstatus;
char buf[BUFSIZ*10];
char zbuf[BUFSIZ*20];
int n;
#ifdef UTIME_EXPECTS_WRITABLE
int change_it_back = 0;
#endif
TRACE(1,"copy_and_unzip(%s,%s)",PATCH_NULL(from),PATCH_NULL(to));
if (noexec)
return 0;
/* If the file to be copied is a link or a device, then just create
the new link or device appropriately. */
if (islink (from))
{
char *source = xreadlink (from);
symlink (source, to);
xfree (source);
return 0;
}
if (isdevice (from))
{
#if defined(HAVE_MKNOD) && defined(HAVE_STRUCT_STAT_ST_RDEV)
if (stat (from, &sb) < 0)
error (1, errno, "cannot stat %s", fn_root(from));
mknod (to, sb.st_mode, sb.st_rdev);
#else
error (1, 0, "cannot copy device files on this system (%s)", fn_root(from));
#endif
}
else
{
/* Not a link or a device... probably a regular file. */
if ((fdin = CVS_OPEN (from, O_RDONLY)) < 0)
{
if(must_exist)
error (1, errno, "cannot open %s for copying", fn_root(from));
else
return -1;
}
if (fstat (fdin, &sb) < 0)
{
if(must_exist)
error (1, errno, "cannot fstat %s", fn_root(from));
else
{
close(fdin);
return -1;
}
}
if (force_overwrite && unlink_file (to) && !existence_error (errno))
error (1, errno, "unable to remove %s", to);
if ((fdout = creat (to, (int) sb.st_mode & 07777)) < 0)
error (1, errno, "cannot create %s for copying", to);
zstatus = inflateInit2 (&zstr, 47);
if(zstatus != Z_OK)
error(1, 0, "expansion error (INIT): (%d)%s", zstatus,zstr.msg);
if (sb.st_size > 0)
{
for (;;)
{
n = read (fdin, buf, sizeof(buf));
if (n == -1)
{
#ifdef EINTR
if (errno == EINTR)
continue;
#endif
error (1, errno, "cannot read file %s for copying", fn_root(from));
}
else if (n == 0)
break;
zstr.next_in = (Bytef*)buf;
zstr.avail_in = n;
while(zstr.avail_in)
{
zstr.next_out = (Bytef*)zbuf;
zstr.avail_out = sizeof(zbuf);
zstatus = inflate (&zstr, 0);
if(zstatus != Z_OK && zstatus != Z_STREAM_END)
error(1,0, "expansion error (inflate): (%d)%s", zstatus,zstr.msg);
n = sizeof(zbuf)-zstr.avail_out;
if (n && write(fdout, zbuf, n) != n) {
error (1, errno, "cannot write file %s for copying", to);
}
}
if(zstatus == Z_STREAM_END)
break;
}
#ifdef HAVE_FSYNC
if (fsync (fdout))
error (1, errno, "cannot fsync file %s after copying", fn_root(to));
#endif
}
zstr.next_out = (Bytef*)zbuf;
zstr.avail_out = sizeof(zbuf);
zstatus = inflate (&zstr, Z_FINISH);
if(zstatus != Z_OK && zstatus != Z_STREAM_END)
error(1,0, "expansion error (Z_FINISH): (%d)%s", zstatus,zstr.msg);
n = sizeof(zbuf)-zstr.avail_out;
if (n && write(fdout, zbuf, n) != n) {
error (1, errno, "cannot write file %s for copying", fn_root(to));
}
zstr.next_in = (Bytef*)buf;
zstr.avail_in = 0;
zstr.next_out = (Bytef*)zbuf;
zstr.avail_out = sizeof(zbuf);
zstatus = inflateEnd(&zstr);
if(zstatus != Z_OK)
error(1,0, "expansion error: %s", zstr.msg);
if (close (fdin) < 0)
error (0, errno, "cannot close %s", fn_root(from));
if (close (fdout) < 0)
error (1, errno, "cannot close %s", fn_root(to));
}
#ifdef UTIME_EXPECTS_WRITABLE
if (!iswritable (to))
{
xchmod (to, 1);
change_it_back = 1;
}
#endif /* UTIME_EXPECTS_WRITABLE */
/* now, set the times for the copied file to match those of the original */
memset ((char *) &t, 0, sizeof (t));
t.actime = sb.st_atime;
t.modtime = sb.st_mtime;
(void) utime (to, &t);
#ifdef UTIME_EXPECTS_WRITABLE
if (change_it_back)
xchmod (to, 0);
#endif /* UTIME_EXPECTS_WRITABLE */
return 0;
}
