/*
* Entry points when compiled without support for ACLs or on an unsupported platform.
*/
-bsub_exit_code build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
+bacl_exit_code build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
{
- return bsub_exit_fatal;
+ return bacl_exit_fatal;
}
-bsub_exit_code parse_acl_stream(JCR *jcr, int stream)
+bacl_exit_code parse_acl_stream(JCR *jcr, int stream)
{
- return bsub_exit_fatal;
+ return bacl_exit_fatal;
}
#else
/*
* Send an ACL stream to the SD.
*/
-static bsub_exit_code send_acl_stream(JCR *jcr, int stream)
+static bacl_exit_code send_acl_stream(JCR *jcr, int stream)
{
BSOCK *sd = jcr->store_bsock;
POOLMEM *msgsave;
#ifdef FD_NO_SEND_TEST
- return bsub_exit_ok;
+ return bacl_exit_ok;
#endif
/*
* Sanity check
*/
if (jcr->acl_data_len <= 0)
- return bsub_exit_ok;
+ return bacl_exit_ok;
/*
* Send header
if (!sd->fsend("%ld %d 0", jcr->JobFiles, stream)) {
Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
sd->bstrerror());
- return bsub_exit_fatal;
+ return bacl_exit_fatal;
}
/*
sd->msglen = 0;
Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
sd->bstrerror());
- return bsub_exit_fatal;
+ return bacl_exit_fatal;
}
jcr->JobBytes += sd->msglen;
if (!sd->signal(BNET_EOD)) {
Jmsg1(jcr, M_FATAL, 0, _("Network send error to SD. ERR=%s\n"),
sd->bstrerror());
- return bsub_exit_fatal;
+ return bacl_exit_fatal;
}
Dmsg1(200, "ACL of file: %s successfully backed up!\n", jcr->last_fname);
- return bsub_exit_ok;
+ return bacl_exit_ok;
}
#if defined(HAVE_AIX_OS)
static int os_access_acl_streams[1] = { STREAM_ACL_AIX_TEXT };
static int os_default_acl_streams[1] = { -1 };
-static bsub_exit_code aix_build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
+static bacl_exit_code aix_build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
{
char *acl_text;
actuallyfree(acl_text);
return send_acl_stream(jcr, STREAM_ACL_AIX_TEXT);
}
- return bsub_exit_nok;
+ return bacl_exit_error;
}
-static bsub_exit_code aix_parse_acl_streams(JCR *jcr, int stream)
+static bacl_exit_code aix_parse_acl_streams(JCR *jcr, int stream)
{
if (acl_put(jcr->last_fname, jcr->acl_data, 0) != 0) {
- return bsub_exit_nok;
+ return bacl_exit_error;
}
- return bsub_exit_ok;
+ return bacl_exit_ok;
}
/*
* For this OS setup the build and parse function pointer to the OS specific functions.
*/
-static bsub_exit_code (*os_build_acl_streams)(JCR *jcr, FF_PKT *ff_pkt) = aix_build_acl_streams;
-static bsub_exit_code (*os_parse_acl_streams)(JCR *jcr, int stream) = aix_parse_acl_streams;
+static bacl_exit_code (*os_build_acl_streams)(JCR *jcr, FF_PKT *ff_pkt) = aix_build_acl_streams;
+static bacl_exit_code (*os_parse_acl_streams)(JCR *jcr, int stream) = aix_parse_acl_streams;
#elif defined(HAVE_DARWIN_OS) || \
defined(HAVE_FREEBSD_OS) || \
/*
* Generic wrapper around acl_get_file call.
*/
-static bsub_exit_code generic_get_acl_from_os(JCR *jcr, bacl_type acltype)
+static bacl_exit_code generic_get_acl_from_os(JCR *jcr, bacl_type acltype)
{
acl_t acl;
acl_type_t ostype;
pm_strcpy(jcr->acl_data, "");
jcr->acl_data_len = 0;
acl_free(acl);
- return bsub_exit_ok;
+ return bacl_exit_ok;
}
#endif
pm_strcpy(jcr->acl_data, "");
jcr->acl_data_len = 0;
acl_free(acl);
- return bsub_exit_ok;
+ return bacl_exit_ok;
}
#endif
jcr->acl_data_len = pm_strcpy(jcr->acl_data, acl_text);
acl_free(acl);
acl_free(acl_text);
- return bsub_exit_ok;
+ return bacl_exit_ok;
}
- Jmsg2(jcr, M_ERROR, 0, _("acl_to_text error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, be.bstrerror());
+ Mmsg2(jcr->errmsg, _("acl_to_text error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, be.bstrerror());
Dmsg2(100, "acl_to_text error file=%s ERR=%s\n",
- jcr->last_fname, be.bstrerror());
+ jcr->last_fname, be.bstrerror());
pm_strcpy(jcr->acl_data, "");
jcr->acl_data_len = 0;
acl_free(acl);
- return bsub_exit_nok;
+ return bacl_exit_error;
}
/*
case ENOENT:
pm_strcpy(jcr->acl_data, "");
jcr->acl_data_len = 0;
- return bsub_exit_ok;
+ return bacl_exit_ok;
default:
/* Some real error */
- Jmsg2(jcr, M_ERROR, 0, _("acl_get_file error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, be.bstrerror());
+ Mmsg2(jcr->errmsg, _("acl_get_file error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, be.bstrerror());
Dmsg2(100, "acl_get_file error file=%s ERR=%s\n",
- jcr->last_fname, be.bstrerror());
+ jcr->last_fname, be.bstrerror());
pm_strcpy(jcr->acl_data, "");
jcr->acl_data_len = 0;
- return bsub_exit_nok;
+ return bacl_exit_error;
}
}
/*
*/
pm_strcpy(jcr->acl_data, "");
jcr->acl_data_len = 0;
- return bsub_exit_ok;
+ return bacl_exit_ok;
}
/*
* Generic wrapper around acl_set_file call.
*/
-static bsub_exit_code generic_set_acl_on_os(JCR *jcr, bacl_type acltype)
+static bacl_exit_code generic_set_acl_on_os(JCR *jcr, bacl_type acltype)
{
acl_t acl;
acl_type_t ostype;
ostype = bac_to_os_acltype(acltype);
if (ostype == ACL_TYPE_DEFAULT && strlen(jcr->acl_data) == 0) {
if (acl_delete_def_file(jcr->last_fname) == 0) {
- return bsub_exit_ok;
+ return bacl_exit_ok;
}
switch (errno) {
case ENOENT:
- return bsub_exit_ok;
+ return bacl_exit_ok;
default:
- Jmsg2(jcr, M_ERROR, 0, _("acl_delete_def_file error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, be.bstrerror());
- return bsub_exit_nok;
+ Mmsg2(jcr->errmsg, _("acl_delete_def_file error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, be.bstrerror());
+ return bacl_exit_error;
}
}
acl = acl_from_text(jcr->acl_data);
if (acl == NULL) {
- Jmsg2(jcr, M_ERROR, 0, _("acl_from_text error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, be.bstrerror());
+ Mmsg2(jcr->errmsg, _("acl_from_text error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, be.bstrerror());
Dmsg3(100, "acl_from_text error acl=%s file=%s ERR=%s\n",
jcr->acl_data, jcr->last_fname, be.bstrerror());
- return bsub_exit_nok;
+ return bacl_exit_error;
}
#ifndef HAVE_FREEBSD_OS
* As it does the right thing, given valid input, just ignore acl_valid().
*/
if (acl_valid(acl) != 0) {
- Jmsg2(jcr, M_ERROR, 0, _("acl_valid error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, be.bstrerror());
+ Mmsg2(jcr->errmsg, _("acl_valid error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, be.bstrerror());
Dmsg3(100, "acl_valid error acl=%s file=%s ERR=%s\n",
jcr->acl_data, jcr->last_fname, be.bstrerror());
acl_free(acl);
- return bsub_exit_nok;
+ return bacl_exit_error;
}
#endif
switch (errno) {
case ENOENT:
acl_free(acl);
- return bsub_exit_nok;
+ return bacl_exit_ok;
default:
- Jmsg2(jcr, M_ERROR, 0, _("acl_set_file error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, be.bstrerror());
+ Mmsg2(jcr->errmsg, _("acl_set_file error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, be.bstrerror());
Dmsg3(100, "acl_set_file error acl=%s file=%s ERR=%s\n",
- jcr->acl_data, jcr->last_fname, be.bstrerror());
+ jcr->acl_data, jcr->last_fname, be.bstrerror());
acl_free(acl);
- return bsub_exit_nok;
+ return bacl_exit_error;
}
}
acl_free(acl);
- return bsub_exit_ok;
+ return bacl_exit_ok;
}
/*
static int os_access_acl_streams[1] = { STREAM_ACL_DARWIN_ACCESS_ACL };
static int os_default_acl_streams[1] = { -1 };
-static bsub_exit_code darwin_build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
+static bacl_exit_code darwin_build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
{
#if defined(ACL_TYPE_EXTENDED)
/*
*
* Read access ACLs for files, dirs and links
*/
- if (generic_get_acl_from_os(jcr, BACL_TYPE_EXTENDED) == bsub_exit_fatal)
- return bsub_exit_fatal;
+ if (generic_get_acl_from_os(jcr, BACL_TYPE_EXTENDED) == bacl_exit_fatal)
+ return bacl_exit_fatal;
#else
/*
* Read access ACLs for files, dirs and links
*/
- if (generic_get_acl_from_os(jcr, BACL_TYPE_ACCESS) == bsub_exit_fatal)
- return bsub_exit_fatal;
+ if (generic_get_acl_from_os(jcr, BACL_TYPE_ACCESS) == bacl_exit_fatal)
+ return bacl_exit_fatal;
#endif
if (jcr->acl_data_len > 0) {
return send_acl_stream(jcr, STREAM_ACL_DARWIN_ACCESS_ACL);
}
- return bsub_exit_ok;
+ return bacl_exit_ok;
}
-static bsub_exit_code darwin_parse_acl_streams(JCR *jcr, int stream)
+static bacl_exit_code darwin_parse_acl_streams(JCR *jcr, int stream)
{
#if defined(ACL_TYPE_EXTENDED)
return generic_set_acl_on_os(jcr, BACL_TYPE_EXTENDED);
/*
* For this OS setup the build and parse function pointer to the OS specific functions.
*/
-static bsub_exit_code (*os_build_acl_streams)(JCR *jcr, FF_PKT *ff_pkt) = darwin_build_acl_streams;
-static bsub_exit_code (*os_parse_acl_streams)(JCR *jcr, int stream) = darwin_parse_acl_streams;
+static bacl_exit_code (*os_build_acl_streams)(JCR *jcr, FF_PKT *ff_pkt) = darwin_build_acl_streams;
+static bacl_exit_code (*os_parse_acl_streams)(JCR *jcr, int stream) = darwin_parse_acl_streams;
#elif defined(HAVE_FREEBSD_OS) || \
defined(HAVE_IRIX_OS) || \
static int os_default_acl_streams[1] = { STREAM_ACL_LINUX_DEFAULT_ACL };
#endif
-static bsub_exit_code generic_build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
+static bacl_exit_code generic_build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
{
/*
* Read access ACLs for files, dirs and links
*/
- if (generic_get_acl_from_os(jcr, BACL_TYPE_ACCESS) == bsub_exit_fatal)
- return bsub_exit_fatal;
+ if (generic_get_acl_from_os(jcr, BACL_TYPE_ACCESS) == bacl_exit_fatal)
+ return bacl_exit_fatal;
if (jcr->acl_data_len > 0) {
- if (send_acl_stream(jcr, os_access_acl_streams[0]) == bsub_exit_fatal)
- return bsub_exit_fatal;
+ if (send_acl_stream(jcr, os_access_acl_streams[0]) == bacl_exit_fatal)
+ return bacl_exit_fatal;
}
/*
* Directories can have default ACLs too
*/
if (ff_pkt->type == FT_DIREND) {
- if (generic_get_acl_from_os(jcr, BACL_TYPE_DEFAULT) == bsub_exit_fatal)
- return bsub_exit_fatal;
+ if (generic_get_acl_from_os(jcr, BACL_TYPE_DEFAULT) == bacl_exit_fatal)
+ return bacl_exit_fatal;
if (jcr->acl_data_len > 0) {
- if (send_acl_stream(jcr, os_default_acl_streams[0]) == bsub_exit_fatal)
- return bsub_exit_fatal;
+ if (send_acl_stream(jcr, os_default_acl_streams[0]) == bacl_exit_fatal)
+ return bacl_exit_fatal;
}
}
- return bsub_exit_ok;
+ return bacl_exit_ok;
}
-static bsub_exit_code generic_parse_acl_streams(JCR *jcr, int stream)
+static bacl_exit_code generic_parse_acl_streams(JCR *jcr, int stream)
{
- int cnt;
+ unsigned int cnt;
switch (stream) {
case STREAM_UNIX_ACCESS_ACL:
}
break;
}
- return bsub_exit_nok;
+ return bacl_exit_error;
}
/*
* For this OSes setup the build and parse function pointer to the OS specific functions.
*/
-static bsub_exit_code (*os_build_acl_streams)(JCR *jcr, FF_PKT *ff_pkt) = generic_build_acl_streams;
-static bsub_exit_code (*os_parse_acl_streams)(JCR *jcr, int stream) = generic_parse_acl_streams;
+static bacl_exit_code (*os_build_acl_streams)(JCR *jcr, FF_PKT *ff_pkt) = generic_build_acl_streams;
+static bacl_exit_code (*os_parse_acl_streams)(JCR *jcr, int stream) = generic_parse_acl_streams;
#elif defined(HAVE_OSF1_OS)
static int os_access_acl_streams[1] = { STREAM_ACL_TRU64_ACCESS_ACL };
static int os_default_acl_streams[2] = { STREAM_ACL_TRU64_DEFAULT_ACL, STREAM_ACL_TRU64_DEFAULT_DIR_ACL };
-static bsub_exit_code tru64_build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
+static bacl_exit_code tru64_build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
{
/*
* Read access ACLs for files, dirs and links
*/
if ((jcr->acl_data_len = generic_get_acl_from_os(jcr, BACL_TYPE_ACCESS)) < 0)
- return bsub_exit_nok;
+ return bacl_exit_error;
if (jcr->acl_data_len > 0) {
if (!send_acl_stream(jcr, STREAM_ACL_TRU64_ACCESS_ACL))
- return bsub_exit_nok;
+ return bacl_exit_error;
}
/*
* Directories can have default ACLs too
*/
if (ff_pkt->type == FT_DIREND) {
if ((jcr->acl_data_len = generic_get_acl_from_os(jcr, BACL_TYPE_DEFAULT)) < 0)
- return bsub_exit_nok;
+ return bacl_exit_error;
if (jcr->acl_data_len > 0) {
if (!send_acl_stream(jcr, STREAM_ACL_TRU64_DEFAULT_ACL))
- return bsub_exit_nok;
+ return bacl_exit_error;
}
/*
* Tru64 has next to BACL_TYPE_DEFAULT also BACL_TYPE_DEFAULT_DIR acls.
* Section 21.5 Default ACLs
*/
if ((jcr->acl_data_len = generic_get_acl_from_os(jcr, BACL_TYPE_DEFAULT_DIR)) < 0)
- return bsub_exit_nok;
+ return bacl_exit_error;
if (jcr->acl_data_len > 0) {
if (!send_acl_stream(jcr, STREAM_ACL_TRU64_DEFAULT_DIR_ACL))
- return bsub_exit_nok;
+ return bacl_exit_error;
}
}
- return bsub_exit_ok;
+ return bacl_exit_ok;
}
-static bsub_exit_code tru64_parse_acl_streams(JCR *jcr, int stream)
+static bacl_exit_code tru64_parse_acl_streams(JCR *jcr, int stream)
{
switch (stream) {
case STREAM_UNIX_ACCESS_ACL:
/*
* For this OS setup the build and parse function pointer to the OS specific functions.
*/
-static bsub_exit_code (*os_build_acl_streams)(JCR *jcr, FF_PKT *ff_pkt) = tru64_build_acl_streams;
-static bsub_exit_code (*os_parse_acl_streams)(JCR *jcr, int stream) = tru64_parse_acl_streams;
+static bacl_exit_code (*os_build_acl_streams)(JCR *jcr, FF_PKT *ff_pkt) = tru64_build_acl_streams;
+static bacl_exit_code (*os_parse_acl_streams)(JCR *jcr, int stream) = tru64_parse_acl_streams;
#endif
/*
* OS specific functions for handling different types of acl streams.
*/
-static bsub_exit_code hpux_build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
+static bacl_exit_code hpux_build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
{
int n;
struct acl_entry acls[NACLENTRIES];
*/
pm_strcpy(jcr->acl_data, "");
jcr->acl_data_len = 0;
- return bsub_exit_ok;
+ return bacl_exit_ok;
#endif
case ENOENT:
pm_strcpy(jcr->acl_data, "");
jcr->acl_data_len = 0;
- return bsub_exit_ok;
+ return bacl_exit_ok;
default:
- Jmsg2(jcr, M_ERROR, 0, _("getacl error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, be.bstrerror());
+ Mmsg2(jcr->errmsg, _("getacl error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, be.bstrerror());
Dmsg2(100, "getacl error file=%s ERR=%s\n",
- jcr->last_fname, be.bstrerror());
+ jcr->last_fname, be.bstrerror());
pm_strcpy(jcr->acl_data, "");
jcr->acl_data_len = 0;
- return bsub_exit_nok;
+ return bacl_exit_error;
}
}
if (n == 0) {
pm_strcpy(jcr->acl_data, "");
jcr->acl_data_len = 0;
- return bsub_exit_ok;
+ return bacl_exit_ok;
}
if ((n = getacl(jcr->last_fname, n, acls)) > 0) {
if (acl_is_trivial(n, acls, ff_pkt->statp)) {
*/
pm_strcpy(jcr->acl_data, "");
jcr->acl_data_len = 0;
- return bsub_exit_ok;
+ return bacl_exit_ok;
}
if ((acl_text = acltostr(n, acls, FORM_SHORT)) != NULL) {
jcr->acl_data_len = pm_strcpy(jcr->acl_data, acl_text);
return send_acl_stream(jcr, STREAM_ACL_HPUX_ACL_ENTRY);
}
- Jmsg2(jcr, M_ERROR, 0, _("acltostr error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, be.bstrerror());
+ Mmsg2(jcr->errmsg, _("acltostr error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, be.bstrerror());
Dmsg3(100, "acltostr error acl=%s file=%s ERR=%s\n",
- jcr->acl_data, jcr->last_fname, be.bstrerror());
- return bsub_exit_nok;
+ jcr->acl_data, jcr->last_fname, be.bstrerror());
+ return bacl_exit_error;
}
- return bsub_exit_nok;
+ return bacl_exit_error;
}
-static bsub_exit_code hpux_parse_acl_streams(JCR *jcr, int stream)
+static bacl_exit_code hpux_parse_acl_streams(JCR *jcr, int stream)
{
int n, stat;
struct acl_entry acls[NACLENTRIES];
n = strtoacl(jcr->acl_data, 0, NACLENTRIES, acls, ACL_FILEOWNER, ACL_FILEGROUP);
if (n <= 0) {
- Jmsg2(jcr, M_ERROR, 0, _("strtoacl error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, be.bstrerror());
+ Mmsg2(jcr->errmsg, _("strtoacl error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, be.bstrerror());
Dmsg3(100, "strtoacl error acl=%s file=%s ERR=%s\n",
- jcr->acl_data, jcr->last_fname, be.bstrerror());
- return bsub_exit_nok;
+ jcr->acl_data, jcr->last_fname, be.bstrerror());
+ return bacl_exit_error;
}
if (strtoacl(jcr->acl_data, n, NACLENTRIES, acls, ACL_FILEOWNER, ACL_FILEGROUP) != n) {
- Jmsg2(jcr, M_ERROR, 0, _("strtoacl error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, be.bstrerror());
+ Mmsg2(jcr->errmsg, _("strtoacl error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, be.bstrerror());
Dmsg3(100, "strtoacl error acl=%s file=%s ERR=%s\n",
- jcr->acl_data, jcr->last_fname, be.bstrerror());
+ jcr->acl_data, jcr->last_fname, be.bstrerror());
- return bsub_exit_nok;
+ return bacl_exit_error;
}
/*
* Restore the ACLs, but don't complain about links which really should
if (setacl(jcr->last_fname, n, acls) != 0 && jcr->last_type != FT_LNK) {
switch (errno) {
case ENOENT:
- return bsub_exit_nok;
+ return bacl_exit_ok;
default:
- Jmsg2(jcr, M_ERROR, 0, _("setacl error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, be.bstrerror());
+ Mmsg2(jcr->errmsg, _("setacl error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, be.bstrerror());
Dmsg3(100, "setacl error acl=%s file=%s ERR=%s\n",
- jcr->acl_data, jcr->last_fname, be.bstrerror());
- return bsub_exit_nok;
+ jcr->acl_data, jcr->last_fname, be.bstrerror());
+ return bacl_exit_error;
}
}
- return bsub_exit_ok;
+ return bacl_exit_ok;
}
/*
* For this OS setup the build and parse function pointer to the OS specific functions.
*/
-static bsub_exit_code (*os_build_acl_streams)(JCR *jcr, FF_PKT *ff_pkt) = hpux_build_acl_streams;
-static bsub_exit_code (*os_parse_acl_streams)(JCR *jcr, int stream) = hpux_parse_acl_streams;
+static bacl_exit_code (*os_build_acl_streams)(JCR *jcr, FF_PKT *ff_pkt) = hpux_build_acl_streams;
+static bacl_exit_code (*os_parse_acl_streams)(JCR *jcr, int stream) = hpux_parse_acl_streams;
#elif defined(HAVE_SUN_OS)
#ifdef HAVE_SYS_ACL_H
* for acls retrieved and stored in the database with older fd versions. If the
* new interface is not defined (Solaris 9 and older we fall back to the old code)
*/
-static bsub_exit_code solaris_build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
+static bacl_exit_code solaris_build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
{
int acl_enabled, flags;
acl_t *aclp;
char *acl_text;
- bsub_exit_code stream_status = bsub_exit_nok;
+ bacl_exit_code stream_status = bacl_exit_error;
berrno be;
/*
case 0:
pm_strcpy(jcr->acl_data, "");
jcr->acl_data_len = 0;
- return bsub_exit_ok;
+ return bacl_exit_ok;
case -1:
- Jmsg2(jcr, M_ERROR, 0, _("pathconf error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, be.bstrerror());
- Dmsg2(100, "pathconf error file=%s ERR=%s\n",
- jcr->last_fname, be.bstrerror());
- return bsub_exit_nok;
+ switch (errno) {
+ case ENOENT:
+ return bacl_exit_ok;
+ default:
+ Mmsg2(jcr->errmsg, _("pathconf error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, be.bstrerror());
+ Dmsg2(100, "pathconf error file=%s ERR=%s\n",
+ jcr->last_fname, be.bstrerror());
+ return bacl_exit_error;
+ }
default:
break;
}
* Get ACL info: don't bother allocating space if there is only a trivial ACL.
*/
if (acl_get(jcr->last_fname, ACL_NO_TRIVIAL, &aclp) != 0) {
- Jmsg2(jcr, M_ERROR, 0, _("acl_get error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, acl_strerror(errno));
- Dmsg2(100, "acl_get error file=%s ERR=%s\n",
- jcr->last_fname, acl_strerror(errno));
- return bsub_exit_nok;
+ switch (errno) {
+ case ENOENT:
+ return bacl_exit_ok;
+ default:
+ Mmsg2(jcr->errmsg, _("acl_get error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, acl_strerror(errno));
+ Dmsg2(100, "acl_get error file=%s ERR=%s\n",
+ jcr->last_fname, acl_strerror(errno));
+ return bacl_exit_error;
+ }
}
if (!aclp) {
*/
pm_strcpy(jcr->acl_data, "");
jcr->acl_data_len = 0;
- return bsub_exit_ok;
+ return bacl_exit_ok;
}
#if defined(ACL_SID_FMT)
return stream_status;
}
-static bsub_exit_code solaris_parse_acl_streams(JCR *jcr, int stream)
+static bacl_exit_code solaris_parse_acl_streams(JCR *jcr, int stream)
{
acl_t *aclp;
int acl_enabled, error;
acl_enabled = pathconf(jcr->last_fname, _PC_ACL_ENABLED);
switch (acl_enabled) {
case 0:
- Jmsg1(jcr, M_ERROR, 0, _("Trying to restore acl on file \"%s\" on filesystem without acl support\n"),
- jcr->last_fname);
- return bsub_exit_nok;
+ Mmsg1(jcr->errmsg, _("Trying to restore acl on file \"%s\" on filesystem without acl support\n"),
+ jcr->last_fname);
+ return bacl_exit_error;
case -1:
- Jmsg2(jcr, M_ERROR, 0, _("pathconf error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, be.bstrerror());
- Dmsg3(100, "pathconf error acl=%s file=%s ERR=%s\n",
- jcr->acl_data, jcr->last_fname, be.bstrerror());
- return bsub_exit_nok;
+ switch (errno) {
+ case ENOENT:
+ return bacl_exit_ok;
+ default:
+ Mmsg2(jcr->errmsg, _("pathconf error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, be.bstrerror());
+ Dmsg3(100, "pathconf error acl=%s file=%s ERR=%s\n",
+ jcr->acl_data, jcr->last_fname, be.bstrerror());
+ return bacl_exit_error;
+ }
default:
/*
* On a filesystem with ACL support make sure this particilar ACL type can be restored.
* An aclent can be restored on filesystems with _ACL_ACLENT_ENABLED or _ACL_ACE_ENABLED support.
*/
if ((acl_enabled & (_ACL_ACLENT_ENABLED | _ACL_ACE_ENABLED)) == 0) {
- Jmsg1(jcr, M_ERROR, 0, _("Trying to restore acl on file \"%s\" on filesystem without aclent acl support\n"),
- jcr->last_fname);
- return bsub_exit_nok;
+ Mmsg1(jcr->errmsg, _("Trying to restore acl on file \"%s\" on filesystem without aclent acl support\n"),
+ jcr->last_fname);
+ return bacl_exit_error;
}
break;
case STREAM_ACL_SOLARIS_ACE:
* An ace can only be restored on a filesystem with _ACL_ACE_ENABLED support.
*/
if ((acl_enabled & _ACL_ACE_ENABLED) == 0) {
- Jmsg1(jcr, M_ERROR, 0, _("Trying to restore acl on file \"%s\" on filesystem without ace acl support\n"),
- jcr->last_fname);
- return bsub_exit_nok;
+ Mmsg1(jcr->errmsg, _("Trying to restore acl on file \"%s\" on filesystem without ace acl support\n"),
+ jcr->last_fname);
+ return bacl_exit_error;
}
break;
default:
}
if ((error = acl_fromtext(jcr->acl_data, &aclp)) != 0) {
- Jmsg2(jcr, M_ERROR, 0, _("acl_fromtext error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, acl_strerror(error));
+ Mmsg2(jcr->errmsg, _("acl_fromtext error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, acl_strerror(error));
Dmsg3(100, "acl_fromtext error acl=%s file=%s ERR=%s\n",
- jcr->acl_data, jcr->last_fname, acl_strerror(error));
- return bsub_exit_nok;
+ jcr->acl_data, jcr->last_fname, acl_strerror(error));
+ return bacl_exit_error;
}
/*
switch (stream) {
case STREAM_ACL_SOLARIS_ACLENT:
if (acl_type(aclp) != ACLENT_T) {
- Jmsg1(jcr, M_ERROR, 0, _("wrong encoding of acl type in acl stream on file \"%s\"\n"),
- jcr->last_fname);
- return bsub_exit_nok;
+ Mmsg1(jcr->errmsg, _("wrong encoding of acl type in acl stream on file \"%s\"\n"),
+ jcr->last_fname);
+ return bacl_exit_error;
}
break;
case STREAM_ACL_SOLARIS_ACE:
if (acl_type(aclp) != ACE_T) {
- Jmsg1(jcr, M_ERROR, 0, _("wrong encoding of acl type in acl stream on file \"%s\"\n"),
- jcr->last_fname);
- return bsub_exit_nok;
+ Mmsg1(jcr->errmsg, _("wrong encoding of acl type in acl stream on file \"%s\"\n"),
+ jcr->last_fname);
+ return bacl_exit_error;
}
break;
default:
* don't save acls of symlinks (which cannot have acls anyhow)
*/
if ((error = acl_set(jcr->last_fname, aclp)) == -1 && jcr->last_type != FT_LNK) {
- Jmsg2(jcr, M_ERROR, 0, _("acl_set error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, acl_strerror(error));
- Dmsg3(100, "acl_set error acl=%s file=%s ERR=%s\n",
- jcr->acl_data, jcr->last_fname, acl_strerror(error));
-
- acl_free(aclp);
- return bsub_exit_nok;
+ switch (errno) {
+ case ENOENT:
+ acl_free(aclp);
+ return bacl_exit_ok;
+ default:
+ Mmsg2(jcr->errmsg, _("acl_set error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, acl_strerror(error));
+ Dmsg3(100, "acl_set error acl=%s file=%s ERR=%s\n",
+ jcr->acl_data, jcr->last_fname, acl_strerror(error));
+ acl_free(aclp);
+ return bacl_exit_error;
+ }
}
acl_free(aclp);
- return bsub_exit_ok;
+ return bacl_exit_ok;
default:
- return bsub_exit_nok;
+ return bacl_exit_error;
} /* end switch (stream) */
}
/*
* OS specific functions for handling different types of acl streams.
*/
-static bsub_exit_code solaris_build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
+static bacl_exit_code solaris_build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
{
int n;
aclent_t *acls;
n = acl(jcr->last_fname, GETACLCNT, 0, NULL);
if (n < MIN_ACL_ENTRIES)
- return bsub_exit_nok;
+ return bacl_exit_error;
acls = (aclent_t *)malloc(n * sizeof(aclent_t));
if (acl(jcr->last_fname, GETACL, n, acls) == n) {
free(acls);
pm_strcpy(jcr->acl_data, "");
jcr->acl_data_len = 0;
- return bsub_exit_ok;
+ return bacl_exit_ok;
}
if ((acl_text = acltotext(acls, n)) != NULL) {
return send_acl_stream(jcr, STREAM_ACL_SOLARIS_ACLENT);
}
- Jmsg2(jcr, M_ERROR, 0, _("acltotext error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, be.bstrerror());
+ Mmsg2(jcr->errmsg, _("acltotext error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, be.bstrerror());
Dmsg3(100, "acltotext error acl=%s file=%s ERR=%s\n",
- jcr->acl_data, jcr->last_fname, be.bstrerror());
+ jcr->acl_data, jcr->last_fname, be.bstrerror());
}
free(acls);
- return bsub_exit_nok;
+ return bacl_exit_error;
}
-static bsub_exit_code solaris_parse_acl_streams(JCR *jcr, int stream)
+static bacl_exit_code solaris_parse_acl_streams(JCR *jcr, int stream)
{
int n;
aclent_t *acls;
acls = aclfromtext(jcr->acl_data, &n);
if (!acls) {
- Jmsg2(jcr, M_ERROR, 0, _("aclfromtext error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, be.bstrerror());
+ Mmsg2(jcr->errmsg, _("aclfromtext error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, be.bstrerror());
Dmsg3(100, "aclfromtext error acl=%s file=%s ERR=%s\n",
- jcr->acl_data, jcr->last_fname, be.bstrerror());
- return bsub_exit_nok;
+ jcr->acl_data, jcr->last_fname, be.bstrerror());
+ return bacl_exit_error;
}
/*
switch (errno) {
case ENOENT:
actuallyfree(acls);
- return bsub_exit_nok;
+ return bacl_exit_ok;
default:
- Jmsg2(jcr, M_ERROR, 0, _("acl(SETACL) error on file \"%s\": ERR=%s\n"),
- jcr->last_fname, be.bstrerror());
+ Mmsg2(jcr->errmsg, _("acl(SETACL) error on file \"%s\": ERR=%s\n"),
+ jcr->last_fname, be.bstrerror());
Dmsg3(100, "acl(SETACL) error acl=%s file=%s ERR=%s\n",
- jcr->acl_data, jcr->last_fname, be.bstrerror());
+ jcr->acl_data, jcr->last_fname, be.bstrerror());
actuallyfree(acls);
- return bsub_exit_nok;
+ return bacl_exit_error;
}
}
actuallyfree(acls);
- return bsub_exit_ok;
+ return bacl_exit_ok;
}
#endif /* HAVE_EXTENDED_ACL */
/*
* For this OS setup the build and parse function pointer to the OS specific functions.
*/
-static bsub_exit_code (*os_build_acl_streams)(JCR *jcr, FF_PKT *ff_pkt) = solaris_build_acl_streams;
-static bsub_exit_code (*os_parse_acl_streams)(JCR *jcr, int stream) = solaris_parse_acl_streams;
+static bacl_exit_code (*os_build_acl_streams)(JCR *jcr, FF_PKT *ff_pkt) = solaris_build_acl_streams;
+static bacl_exit_code (*os_parse_acl_streams)(JCR *jcr, int stream) = solaris_parse_acl_streams;
#endif /* HAVE_SUN_OS */
/*
* Read and send an ACL for the last encountered file.
*/
-bsub_exit_code build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
+bacl_exit_code build_acl_streams(JCR *jcr, FF_PKT *ff_pkt)
{
/*
* Call the appropriate function.
if (os_build_acl_streams) {
return (*os_build_acl_streams)(jcr, ff_pkt);
}
- return bsub_exit_nok;
+ return bacl_exit_error;
}
-bsub_exit_code parse_acl_streams(JCR *jcr, int stream)
+bacl_exit_code parse_acl_streams(JCR *jcr, int stream)
{
- int cnt;
+ unsigned int cnt;
switch (stream) {
case STREAM_UNIX_ACCESS_ACL:
Qmsg2(jcr, M_WARNING, 0,
_("Can't restore ACLs of %s - incompatible acl stream encountered - %d\n"),
jcr->last_fname, stream);
- return bsub_exit_nok;
+ return bacl_exit_error;
}
#endif
projects / bacula / bacula / blobdiff