/*---------------------------------------------------------------------------*/
static coffee_page_t
find_contiguous_pages(coffee_page_t amount)
{
coffee_page_t page, start;
struct file_header hdr;
start = INVALID_PAGE;
for(page = *next_free; page < COFFEE_PAGE_COUNT;) {
read_header(&hdr, page);
if(HDR_FREE(hdr)) {
if(start == INVALID_PAGE) {
start = page;
if(start + amount >= COFFEE_PAGE_COUNT) {
/* We can stop immediately if the remaining pages are not enough. */
break;
}
}
/* All remaining pages in this sector are free --
jump to the next sector. */
page = next_file(page, &hdr);
if(start + amount <= page) {
if(start == *next_free) {
*next_free = start + amount;
}
return start;
}
} else {
start = INVALID_PAGE;
page = next_file(page, &hdr);
}
}
return INVALID_PAGE;
}
/*---------------------------------------------------------------------------*/
int
cfs_readdir(struct cfs_dir *dir, struct cfs_dirent *record)
{
struct file_header hdr;
coffee_page_t page;
memcpy(&page, dir->dummy_space, sizeof(coffee_page_t));
while(page < COFFEE_PAGE_COUNT) {
read_header(&hdr, page);
if(HDR_ACTIVE(hdr) && !HDR_LOG(hdr)) {
coffee_page_t next_page;
memcpy(record->name, hdr.name, sizeof(record->name));
record->name[sizeof(record->name) - 1] = '\0';
record->size = file_end(page);
next_page = next_file(page, &hdr);
memcpy(dir->dummy_space, &next_page, sizeof(coffee_page_t));
return 0;
}
page = next_file(page, &hdr);
}
return -1;
}
bool CgCompressCreator::create( const QString& path, int, int, QImage& img ){
qCDebug(LOG) << "Trying to read image" << path;
QFile file(path);
if( !file.open( QIODevice::ReadOnly ) )
return false;
archive* a = archive_read_new();
archive_read_support_format_zip(a);
ReadingData data( file );
if( archive_read_open( a, &data, nullptr, stream_read, stream_close ) )
qCWarning(LOG) << "couldn't open:" << archive_error_string(a);
else{
QString name;
while( !(name = next_file( a )).isNull() ){
if( name.startsWith( "Thumbnails/thumbnail." ) || name.startsWith("thumb.") ){
qCDebug(LOG) << "Found thumbnail!";
QString suffix = QFileInfo(name).suffix();
img = read_image( a, suffix.toLocal8Bit().constData() );
break;
}
}
}
archive_read_close( a );
archive_read_free( a );
if( img.isNull() )
qCWarning(LOG) << "No thumbnail found!";
return !img.isNull();
}
// TODO(Jan): Solve this without the additional alloc/copy operation
void do_put(const Derived& item) {
if (file_limit_reached()) {
next_file();
}
*oarchive_ << item;
++file_item_count_;
}
anyrequests ()
#endif
{
long lastdir = -1;
char * name;
/*
* This routine walks through the requests (secure)
* directory looking for files, descending one level
* into each sub-directory, if any. Finding at least
* one file means that a request is queued.
*/
while ((name = next_dir(Lp_Requests, &lastdir))) {
long lastfile = -1;
char * subdir;
if (!(subdir = makepath(Lp_Requests, name, (char *)0)))
return (1); /* err on safe side */
if (next_file(subdir, &lastfile)) {
Free (subdir);
return (1);
}
Free (subdir);
}
return (0);
}
/**
* Transforms SSML into file_string format and opens file_string.
* @param handle
* @param path the inline SSML
* @return SWITCH_STATUS_SUCCESS if opened
*/
static switch_status_t ssml_file_open(switch_file_handle_t *handle, const char *path)
{
switch_status_t status = SWITCH_STATUS_FALSE;
struct ssml_context *context = switch_core_alloc(handle->memory_pool, sizeof(*context));
struct ssml_parser *parsed_data = switch_core_alloc(handle->memory_pool, sizeof(*parsed_data));
iksparser *parser = iks_sax_new(parsed_data, tag_hook, cdata_hook);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Open: %s\n", path);
parsed_data->cur_node = NULL;
parsed_data->files = switch_core_alloc(handle->memory_pool, sizeof(struct ssml_file) * MAX_VOICE_FILES);
parsed_data->max_files = MAX_VOICE_FILES;
parsed_data->num_files = 0;
parsed_data->pool = handle->memory_pool;
parsed_data->sample_rate = handle->samplerate;
if (iks_parse(parser, path, 0, 1) == IKS_OK) {
if (parsed_data->num_files) {
context->files = parsed_data->files;
context->num_files = parsed_data->num_files;
context->index = -1;
handle->private_info = context;
status = next_file(handle);
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "No files to play: %s\n", path);
}
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Parse error: %s, num_files = %i\n", path, parsed_data->num_files);
}
iks_parser_delete(parser);
return status;
}
static void
apply_mask (struct stat *sf)
{
need_update = TRUE;
end_chmod = TRUE;
do_chmod (sf);
do
{
char *fname;
vfs_path_t *vpath;
gboolean ok;
fname = next_file ();
vpath = vfs_path_from_str (fname);
ok = (mc_stat (vpath, sf) == 0);
vfs_path_free (vpath);
if (!ok)
return;
c_stat = sf->st_mode;
do_chmod (sf);
}
while (current_panel->marked != 0);
}
/*---------------------------------------------------------------------------*/
static struct file *
find_file(const char *name)
{
int i;
struct file_header hdr;
coffee_page_t page;
/* First check if the file metadata is cached. */
for(i = 0; i < COFFEE_MAX_OPEN_FILES; i++) {
if(FILE_FREE(&coffee_files[i])) {
continue;
}
read_header(&hdr, coffee_files[i].page);
if(HDR_ACTIVE(hdr) && !HDR_LOG(hdr) && strcmp(name, hdr.name) == 0) {
return &coffee_files[i];
}
}
/* Scan the flash memory sequentially otherwise. */
for(page = 0; page < COFFEE_PAGE_COUNT; page = next_file(page, &hdr)) {
read_header(&hdr, page);
if(HDR_ACTIVE(hdr) && !HDR_LOG(hdr) && strcmp(name, hdr.name) == 0) {
return load_file(page, &hdr);
}
}
return NULL;
}
/**
* Transforms Rayo document into sub-format and opens file_string.
* @param handle
* @param path the inline Rayo document
* @return SWITCH_STATUS_SUCCESS if opened
*/
static switch_status_t rayo_file_open(switch_file_handle_t *handle, const char *path)
{
switch_status_t status = SWITCH_STATUS_FALSE;
struct rayo_file_context *context = switch_core_alloc(handle->memory_pool, sizeof(*context));
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Got path %s\n", path);
context->component = RAYO_COMPONENT_LOCATE(path);
if (context->component) {
handle->private_info = context;
context->cur_doc = NULL;
context->play_count = 0;
context->could_open = 0;
status = next_file(handle);
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "File error! %s\n", path);
return SWITCH_STATUS_FALSE;
}
if (status != SWITCH_STATUS_SUCCESS && context->component) {
/* complete error event will be sent by calling thread */
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Status = %i\n", status);
RAYO_RELEASE(context->component);
}
return status;
}
file_bstore::file_bstore(const std::string& dir, bool create)
: m_size(0)
, m_root(0)
, m_next_slab(0)
, m_cur_slab(NULL)
{
lock_t lock(m_mutex);
// Set the directory
m_dir = dir;
// Try to open the directory
DIR* d = opendir(dir.c_str());
// If it's not there and create is set:
if (d == NULL && create)
{
// Try to create the directory, thow if fail
if (mkdir(dir.c_str(), 0755) != 0)
throw io_exception("Unable to create directory");
// Make an initial file
next_file();
return;
}
// Otherwise, let's see what's in the directory
struct dirent* de = readdir(d);
while(de)
{
std::string filename = de->d_name;
int slab_num = 0;
// If it matches our naming convention...
if (filename.size() > 5
&& filename.substr(0, 5) == "data_")
{
// Todo: make sure this is really a number
slab_num = atoi(filename.substr(5).c_str());
add_file(filename); // Add the file
m_next_slab = std::max(m_next_slab, (unsigned int) (slab_num + 1)); // Prep the slab number
}
// Find next file
de = readdir(d);
}
// If there was nothing, add a file
if (m_slabs.size() == 0)
next_file();
else
m_root = find_root();
}
/*---------------------------------------------------------------------------*/
int
cfs_readdir(struct cfs_dir *dir, struct cfs_dirent *record)
{
struct file_header hdr;
coffee_page_t page;
for(page = *(coffee_page_t *)dir->dummy_space; page < COFFEE_PAGE_COUNT;) {
watchdog_periodic();
read_header(&hdr, page);
if(HDR_ACTIVE(hdr) && !HDR_LOG(hdr)) {
memcpy(record->name, hdr.name, sizeof(record->name));
record->name[sizeof(record->name) - 1] = '\0';
record->size = file_end(page);
*(coffee_page_t *)dir->dummy_space = next_file(page, &hdr);
return 0;
}
page = next_file(page, &hdr);
}
return -1;
}
off_t file_bstore::write_record(char prefix, const std::vector<char>& record)
{
off_t r = m_size;
off_t slab_start = m_slabs.rbegin()->first;
m_cur_slab->seek_end();
m_cur_slab->write(&prefix, 1);
serialize(*m_cur_slab, record.size());
m_cur_slab->write(record.data(), record.size());
m_size = slab_start + m_cur_slab->get_offset();
if (m_size - slab_start >= (off_t) k_goal_slab_size)
next_file();
return r;
}
static void
apply_chowns (uid_t u, gid_t g)
{
char *fname;
need_update = end_chown = 1;
do_chown (u,g);
do {
fname = next_file ();
do_chown (u,g);
} while (cpanel->marked);
}
static void
apply_chowns (uid_t u, gid_t g)
{
need_update = end_chown = 1;
do_chown (u, g);
do
{
next_file ();
do_chown (u, g);
}
while (current_panel->marked);
}
int main(int argc, char** argv)
{
int result = -1;
Cookie cookie;
memset(&cookie, 0, sizeof(Cookie));
next_file(&cookie);
for (;;)
{
uint8_t name_size;
char* name = NULL;
#if 0
printf("Volume %i, offset 0x%08lx\n", cookie.index, ftell(cookie.input_file));
#endif
if (sizeof(name_size) != reader(&name_size, sizeof(name_size), &cookie))
break;
name = malloc(MAX_FILENAME_SIZE);
if (MAX_FILENAME_SIZE != reader(name, MAX_FILENAME_SIZE, &cookie))
{
fprintf(stderr, "read name failed\n");
break;
}
name[name_size] = '\0';
printf("extracting: %s\n", name);
cookie.output_file = fopen(name, "w");
result = dynamite_explode(reader, writer, &cookie);
FCLOSE(cookie.output_file);
if (DYNAMITE_SUCCESS != result)
{
fprintf(stderr, "Error %i\n", result);
break;
}
}
FCLOSE(cookie.input_file);
FCLOSE(cookie.output_file);
return result;
}
static void
apply_advanced_chowns (struct stat *sf)
{
vfs_path_t *vpath;
char *lc_fname;
gid_t a_gid = sf->st_gid;
uid_t a_uid = sf->st_uid;
lc_fname = current_panel->dir.list[current_file].fname;
vpath = vfs_path_from_str (lc_fname);
need_update = end_chown = TRUE;
if (mc_chmod (vpath, get_mode ()) == -1)
message (D_ERROR, MSG_ERROR, _("Cannot chmod \"%s\"\n%s"),
lc_fname, unix_error_string (errno));
/* call mc_chown only, if mc_chmod didn't fail */
else if (mc_chown (vpath, (ch_flags[9] == '+') ? sf->st_uid : (uid_t) (-1),
(ch_flags[10] == '+') ? sf->st_gid : (gid_t) (-1)) == -1)
message (D_ERROR, MSG_ERROR, _("Cannot chown \"%s\"\n%s"),
lc_fname, unix_error_string (errno));
do_file_mark (current_panel, current_file, 0);
vfs_path_free (vpath);
do
{
lc_fname = next_file ();
vpath = vfs_path_from_str (lc_fname);
if (mc_stat (vpath, sf) != 0)
{
vfs_path_free (vpath);
break;
}
ch_cmode = sf->st_mode;
if (mc_chmod (vpath, get_mode ()) == -1)
message (D_ERROR, MSG_ERROR, _("Cannot chmod \"%s\"\n%s"),
lc_fname, unix_error_string (errno));
/* call mc_chown only, if mc_chmod didn't fail */
else if (mc_chown (vpath, (ch_flags[9] == '+') ? a_uid : (uid_t) (-1),
(ch_flags[10] == '+') ? a_gid : (gid_t) (-1)) == -1)
message (D_ERROR, MSG_ERROR, _("Cannot chown \"%s\"\n%s"),
lc_fname, unix_error_string (errno));
do_file_mark (current_panel, current_file, 0);
vfs_path_free (vpath);
}
while (current_panel->marked != 0);
}
static size_t reader(void* buffer, size_t size, void* cookie)
{
size_t result = fread(buffer, 1, size, ((Cookie*)cookie)->input_file);
if (result < size)
{
next_file((Cookie*)cookie);
if (((Cookie*)cookie)->input_file)
{
buffer += result;
result += fread(buffer, 1, size - result, ((Cookie*)cookie)->input_file);
}
}
return result;
}
static void apply_mask (struct stat *sf)
{
char *fname;
need_update = end_chmod = 1;
do_chmod (sf);
do {
fname = next_file ();
if (mc_stat (fname, sf) != 0)
return;
c_stat = sf->st_mode;
do_chmod (sf);
} while (current_panel->marked);
}
/**
* Read from SSML document
* @param handle
* @param data
* @param len
* @return
*/
static switch_status_t ssml_file_read(switch_file_handle_t *handle, void *data, size_t *len)
{
switch_status_t status;
struct ssml_context *context = (struct ssml_context *)handle->private_info;
size_t llen = *len;
status = switch_core_file_read(&context->fh, data, len);
if (status != SWITCH_STATUS_SUCCESS) {
if ((status = next_file(handle)) != SWITCH_STATUS_SUCCESS) {
return status;
}
*len = llen;
status = switch_core_file_read(&context->fh, data, len);
}
return status;
}
/**
* Seek file
*/
static switch_status_t ssml_file_seek(switch_file_handle_t *handle, unsigned int *cur_sample, int64_t samples, int whence)
{
struct ssml_context *context = handle->private_info;
if (samples == 0 && whence == SWITCH_SEEK_SET) {
/* restart from beginning */
context->index = -1;
return next_file(handle);
}
if (!handle->seekable) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "File is not seekable\n");
return SWITCH_STATUS_NOTIMPL;
}
return switch_core_file_seek(&context->fh, cur_sample, samples, whence);
}
/**
* \brief Construct an output archive object, open the first archive file
* for writing, and write the archive descriptor. All occurences of the
* placeholder "%n" in the filename_template are replaced by a sequence
* number.
*
* \param filename_template File name pattern of the archive files
* \param items_per_file Number of items to store in each file
*/
OutputArchiveSequence(const std::string& filename_template,
std::size_t items_per_file = SIZE_MAX,
std::size_t bytes_per_file = SIZE_MAX)
: filename_template_(filename_template), items_per_file_(items_per_file),
bytes_per_file_(bytes_per_file) {
if (items_per_file_ == 0) {
items_per_file_ = SIZE_MAX;
}
if (bytes_per_file_ == 0) {
bytes_per_file_ = SIZE_MAX;
}
// append sequence number to file name if missing in template
if (items_per_file_ < SIZE_MAX &&
filename_template_.find("%n") == std::string::npos) {
filename_template_ += ".%n";
}
next_file();
}
/**
* Read from SSML document
* @param handle
* @param data
* @param len
* @return
*/
static switch_status_t rayo_file_read(switch_file_handle_t *handle, void *data, size_t *len)
{
switch_status_t status;
struct rayo_file_context *context = (struct rayo_file_context *)handle->private_info;
size_t llen = *len;
if (OUTPUT_COMPONENT(context->component)->stop) {
return SWITCH_STATUS_FALSE;
} else {
status = switch_core_file_read(&context->fh, data, len);
if (status != SWITCH_STATUS_SUCCESS) {
if ((status = next_file(handle)) != SWITCH_STATUS_SUCCESS) {
return status;
}
*len = llen;
status = switch_core_file_read(&context->fh, data, len);
}
}
return status;
}
static void apply_advanced_chowns (struct stat *sf)
{
char *fname;
gid_t a_gid = sf->st_gid;
uid_t a_uid = sf->st_uid;
fname = current_panel->dir.list[current_file].fname;
need_update = end_chown = 1;
if (mc_chmod (fname, get_mode ()) == -1)
message (D_ERROR, MSG_ERROR, _(" Cannot chmod \"%s\" \n %s "),
fname, unix_error_string (errno));
/* call mc_chown only, if mc_chmod didn't fail */
else if (mc_chown (fname, (ch_flags[9] == '+') ? sf->st_uid : (uid_t) -1,
(ch_flags[10] == '+') ? sf->st_gid : (gid_t) -1) == -1)
message (D_ERROR, MSG_ERROR, _(" Cannot chown \"%s\" \n %s "),
fname, unix_error_string (errno));
do_file_mark (current_panel, current_file, 0);
do {
fname = next_file ();
if (mc_stat (fname, sf) != 0)
break;
ch_cmode = sf->st_mode;
if (mc_chmod (fname, get_mode ()) == -1)
message (D_ERROR, MSG_ERROR, _(" Cannot chmod \"%s\" \n %s "),
fname, unix_error_string (errno));
/* call mc_chown only, if mc_chmod didn't fail */
else if (mc_chown (fname, (ch_flags[9] == '+') ? a_uid : (uid_t) -1,
(ch_flags[10] == '+') ? a_gid : (gid_t) -1) == -1)
message (D_ERROR, MSG_ERROR, _(" Cannot chown \"%s\" \n %s "),
fname, unix_error_string (errno));
do_file_mark (current_panel, current_file, 0);
} while (current_panel->marked);
}
int
main(int argc, char *argv[])
{
int i, j, fd, rc, nops, lastOps;
int ag_ops = 0;
double ag_interval = 0;
double ag_rate = 0;
double rate, avg_rate, effective_rate;
double startTime, curTime, lastTime, interval;
time_t timestamp;
char * file;
rc = MPI_Init(&argc, &argv);
if (rc != MPI_SUCCESS)
fatal(myrank, "MPI_Init failed: %d\n", rc);
rc = MPI_Comm_size(MPI_COMM_WORLD, &nthreads);
if (rc != MPI_SUCCESS)
fatal(myrank, "MPI_Comm_size failed: %d\n", rc);
rc = MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
if (rc != MPI_SUCCESS)
fatal(myrank, "MPI_Comm_rank failed: %d\n", rc);
process_args(argc, argv);
timestamp = time(0);
if ((myrank == 0) || debug) {
printf("%d: %s starting at %s",
myrank, hostname, ctime(×tamp));
}
/* if we're not measuring creation rates then precreate
* the files we're operating on. */
if ((mode != CREATE) && (mode != MKNOD) && !ignore &&
(mode != UNLINK || recreate)) {
/* create the files in reverse order. When we encounter
* a file that already exists, assume the remainder of
* the files exist to save time. The timed performance
* test scripts make use of this behavior. */
for (i = end, j = 0; i >= begin; i -= dirthreads) {
sprintf(filename, filefmt, i);
fd = open(filename, openflags, 0644);
if (fd < 0) {
if (errno == EEXIST)
break;
rc = errno;
fatal(myrank, "precreate open(%s) error: %s\n",
filename, strerror(rc));
}
j++;
close(fd);
}
dmesg("%d: %s pre-created %d files.\n",myrank,hostname,j);
rc = MPI_Barrier(MPI_COMM_WORLD);
if (rc != MPI_SUCCESS)
fatal(myrank, "prep MPI_Barrier failed: %d\n", rc);
}
if (order == READDIR) {
directory = opendir(dir);
if (directory == NULL) {
rc = errno;
fatal(myrank, "opendir(%s) error: %s\n",
dir, strerror(rc));
}
timestamp = time(0);
j = random() % nfiles;
dmesg("%d: %s initializing dir offset %u: %s",
myrank, hostname, j, ctime(×tamp));
for (i = 0; i <= j; i++) {
if ((dir_entry = readdir(directory)) == NULL) {
fatal(myrank, "could not read entry number %d "
"in directory %s.\n", i, dir);
}
}
timestamp = time(0);
dmesg("%d: index %d, filename %s, offset %ld: "
"%s initialization complete: %s",
myrank, i, dir_entry->d_name, telldir(directory),
hostname, ctime(×tamp));
}
if (seconds) {
act.sa_handler = sigalrm_handler;
(void)sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGALRM, &act, NULL);
alarm(seconds);
}
rc = MPI_Barrier(MPI_COMM_WORLD);
if (rc != MPI_SUCCESS)
fatal(myrank, "prep MPI_Barrier failed: %d\n", rc);
startTime = lastTime = MPI_Wtime();
nops = lastOps = 0;
switch (mode) {
case CREATE:
for (; begin <= end && !alarm_caught; begin += dirthreads) {
snprintf(filename, sizeof(filename), filefmt, begin);
fd = open(filename, openflags, 0644);
if (fd < 0) {
rc = errno;
if (rc == EINTR && alarm_caught)
break;
fatal(myrank, "open(%s) error: %s\n",
filename, strerror(rc));
}
if (with_xattr) {
rc = fsetxattr(fd, xattrname, xattrbuf,
xattrlen, XATTR_CREATE);
if (rc) {
rc = errno;
if (rc == EINTR && alarm_caught)
break;
fatal(myrank,
"setxattr(%s) error: %s\n",
filename, strerror(rc));
}
}
if (smallwrite) {
rc = write(fd, xattrbuf, xattrlen);
if (rc < 0) {
rc = errno;
if (rc == EINTR && alarm_caught)
break;
fatal(myrank,
"write(%s) error: %s\n",
filename, strerror(rc));
}
}
close(fd);
nops++;
DISPLAY_PROGRESS();
}
dmesg("%d: created %d files, last file '%s'.\n",
myrank, nops, filename);
break;
#ifdef HAVE_MDC_LOOKUP
case LOOKUP:
fd = open(dir, O_RDONLY);
if (fd < 0) {
fatal(myrank, "open(dir == '%s') error: %s\n",
dir, strerror(errno));
}
for (; nops < iters && !alarm_caught;) {
char *filename = next_file();
rc = llapi_file_lookup(fd, filename);
if (rc < 0) {
if (((rc = errno) == EINTR) && alarm_caught)
break;
fatal(myrank, "llapi_file_lookup(%s) "
"error: %s\n", filename, strerror(rc));
}
nops++;
DISPLAY_PROGRESS();
}
break;
#endif
case MKNOD:
for (; begin <= end && !alarm_caught; begin += dirthreads) {
snprintf(filename, sizeof(filename), filefmt, begin);
rc = mknod(filename, S_IFREG | 0644, 0);
if (rc) {
rc = errno;
if (rc == EINTR && alarm_caught)
break;
fatal(myrank, "mknod(%s) error: %s\n",
filename, strerror(rc));
}
if (with_xattr) {
rc = setxattr(filename, xattrname, xattrbuf,
xattrlen, XATTR_CREATE);
if (rc) {
rc = errno;
if (rc == EINTR && alarm_caught)
break;
fatal(myrank,
"setxattr(%s) error: %s\n",
filename, strerror(rc));
}
}
nops++;
DISPLAY_PROGRESS();
}
break;
case OPEN:
for (; nops < iters && !alarm_caught;) {
file = next_file();
if ((fd = open(file, openflags, 0644)) < 0) {
if (((rc = errno) == EINTR) && alarm_caught)
break;
fatal(myrank, "open(%s) error: %s\n",
file, strerror(rc));
}
close(fd);
nops++;
DISPLAY_PROGRESS();
}
break;
case STAT:
for (; begin <= end && !alarm_caught; begin += dirthreads) {
sprintf(filename, filefmt, begin);
rc = stat(filename, &statbuf);
if (rc) {
if (((rc = errno) == EINTR) && alarm_caught)
break;
if (((rc = errno) == ENOENT) && ignore)
continue;
fatal(myrank, "stat(%s) error: %s\n",
filename, strerror(rc));
}
nops++;
DISPLAY_PROGRESS();
}
break;
case UNLINK:
for (; begin <= end && !alarm_caught; begin += dirthreads) {
sprintf(filename, filefmt, begin);
rc = unlink(filename);
if (rc) {
if (((rc = errno) == EINTR) && alarm_caught)
break;
if ((rc = errno) == ENOENT) {
if (ignore)
continue;
/* no more files to unlink */
break;
}
fatal(myrank, "unlink(%s) error: %s\n",
filename, strerror(rc));
}
nops++;
DISPLAY_PROGRESS();
}
break;
case SETXATTR:
for (; begin <= end && !alarm_caught; begin += dirthreads) {
snprintf(filename, sizeof(filename), filefmt, begin);
rc = setxattr(filename, xattrname, xattrbuf, xattrlen,
XATTR_CREATE);
if (rc) {
rc = errno;
if (rc == EINTR && alarm_caught)
break;
if (rc == ENOENT && ignore)
continue;
fatal(myrank, "setxattr(%s) error: %s\n",
filename, strerror(rc));
}
nops++;
DISPLAY_PROGRESS();
}
break;
}
rc = MPI_Barrier(MPI_COMM_WORLD);
if (rc != MPI_SUCCESS)
fatal(myrank, "prep MPI_Barrier failed: %d\n", rc);
curTime = MPI_Wtime();
interval = curTime - startTime;
rate = (double) (nops) / interval;
rc = MPI_Reduce(&nops, &ag_ops, 1, MPI_INT, MPI_SUM, 0,
MPI_COMM_WORLD);
if (rc != MPI_SUCCESS) {
fatal(myrank, "Failure in MPI_Reduce of total ops.\n");
}
rc = MPI_Reduce(&interval, &ag_interval, 1, MPI_DOUBLE, MPI_SUM, 0,
MPI_COMM_WORLD);
if (rc != MPI_SUCCESS) {
fatal(myrank, "Failure in MPI_Reduce of total interval.\n");
}
rc = MPI_Reduce(&rate, &ag_rate, 1, MPI_DOUBLE, MPI_SUM, 0,
MPI_COMM_WORLD);
if (rc != MPI_SUCCESS) {
fatal(myrank, "Failure in MPI_Reduce of aggregated rate.\n");
}
if (myrank == 0) {
curTime = MPI_Wtime();
interval = curTime - startTime;
effective_rate = (double) ag_ops / interval;
avg_rate = (double) ag_ops / ag_interval;
printf("Rate: %.2f eff %.2f aggr %.2f avg client %ss/sec "
"(total: %d threads %d %ss %d dirs %d threads/dir %.2f secs)\n",
effective_rate, ag_rate, avg_rate, cmd, nthreads, ag_ops,
cmd, ndirs, dirthreads, interval);
if (mode == UNLINK && !recreate && !ignore && ag_ops != nfiles)
printf("Warning: only unlinked %d files instead of %d"
"\n", ag_ops, nfiles);
}
if (recreate) {
for (begin = beginsave; begin <= end; begin += dirthreads) {
sprintf(filename, filefmt, begin);
if ((fd = open(filename, openflags, 0644)) < 0) {
rc = errno;
if (rc == EEXIST)
break;
fatal(myrank, "recreate open(%s) error: %s\n",
filename, strerror(rc));
}
close(fd);
}
}
timestamp = time(0);
if ((myrank == 0) || debug) {
printf("%d: %s finished at %s",
myrank, hostname, ctime(×tamp));
}
MPI_Finalize();
return(0);
}
void
chown_advanced_cmd (void)
{
/* Number of files at startup */
int files_on_begin;
files_on_begin = MAX (1, current_panel->marked);
do
{ /* do while any files remaining */
int file_idx;
char buffer[BUF_MEDIUM];
vfs_path_t *vpath;
int result;
init_chown_advanced ();
if (current_panel->marked)
fname = next_file (); /* next marked file */
else
fname = selection (current_panel)->fname; /* single file */
vpath = vfs_path_from_str (fname);
if (mc_stat (vpath, sf_stat) != 0)
{ /* get status of file */
dlg_destroy (ch_dlg);
vfs_path_free (vpath);
break;
}
ch_cmode = sf_stat->st_mode;
file_idx = files_on_begin == 1 ? 1 : (files_on_begin - current_panel->marked + 1);
g_snprintf (buffer, sizeof (buffer), "%s (%d/%d)",
str_fit_to_term (fname, WIDGET (ch_dlg)->cols - 20, J_LEFT_FIT),
file_idx, files_on_begin);
label_set_text (l_filename, buffer);
chown_refresh ();
update_ownership ();
result = dlg_run (ch_dlg);
switch (result)
{
case B_CANCEL:
end_chown = TRUE;
break;
case B_ENTER:
need_update = TRUE;
if (mc_chmod (vpath, get_mode ()) == -1)
message (D_ERROR, MSG_ERROR, _("Cannot chmod \"%s\"\n%s"),
fname, unix_error_string (errno));
/* call mc_chown only, if mc_chmod didn't fail */
else if (mc_chown
(vpath, (ch_flags[9] == '+') ? sf_stat->st_uid : (uid_t) (-1),
(ch_flags[10] == '+') ? sf_stat->st_gid : (gid_t) (-1)) == -1)
message (D_ERROR, MSG_ERROR, _("Cannot chown \"%s\"\n%s"), fname,
unix_error_string (errno));
break;
case B_SETALL:
apply_advanced_chowns (sf_stat);
break;
case B_SKIP:
default:
break;
}
if (current_panel->marked && result != B_CANCEL)
{
do_file_mark (current_panel, current_file, 0);
need_update = TRUE;
}
dlg_destroy (ch_dlg);
vfs_path_free (vpath);
}
while (current_panel->marked && !end_chown);
chown_advanced_done ();
}
/*
* Main command processor.
* Accept and execute commands until a quit command, then return.
*/
void
commands(void)
{
int c, action;
last_mca = 0;
nscroll = (sc_height + 1) / 2;
for (;;) {
mca = 0;
number = 0;
/*
* See if any signals need processing.
*/
if (sigs) {
psignals();
if (quitting)
quit();
}
/*
* Display prompt and accept a character.
*/
CMD_RESET;
if (!prompt()) {
next_file(1);
continue;
}
noprefix();
c = getcc();
again: if (sigs)
continue;
/*
* If we are in a multicharacter command, call mca_char.
* Otherwise we call cmd_decode to determine the
* action to be performed.
*/
if (mca)
switch (mca_char(c)) {
case MCA_MORE:
/*
* Need another character.
*/
c = getcc();
goto again;
case MCA_DONE:
/*
* Command has been handled by mca_char.
* Start clean with a prompt.
*/
continue;
case NO_MCA:
/*
* Not a multi-char command
* (at least, not anymore).
*/
break;
}
/* decode the command character and decide what to do. */
switch (action = cmd_decode(c)) {
case A_DIGIT: /* first digit of a number */
start_mca(A_DIGIT, ":");
goto again;
case A_F_SCREEN: /* forward one screen */
CMD_EXEC;
if (number <= 0 && (number = sc_window) <= 0)
number = sc_height - 1;
forward(number, 1);
break;
case A_B_SCREEN: /* backward one screen */
CMD_EXEC;
if (number <= 0 && (number = sc_window) <= 0)
number = sc_height - 1;
backward(number, 1);
break;
case A_F_LINE: /* forward N (default 1) line */
CMD_EXEC;
forward(number <= 0 ? 1 : number, 0);
break;
case A_B_LINE: /* backward N (default 1) line */
CMD_EXEC;
backward(number <= 0 ? 1 : number, 0);
break;
case A_F_SCROLL: /* forward N lines */
CMD_EXEC;
if (number > 0)
nscroll = number;
forward(nscroll, 0);
break;
case A_B_SCROLL: /* backward N lines */
CMD_EXEC;
if (number > 0)
nscroll = number;
backward(nscroll, 0);
break;
case A_FREPAINT: /* flush buffers and repaint */
if (!ispipe) {
ch_init(0, 0);
clr_linenum();
}
/* FALLTHROUGH */
case A_REPAINT: /* repaint the screen */
CMD_EXEC;
repaint();
break;
case A_GOLINE: /* go to line N, default 1 */
CMD_EXEC;
if (number <= 0)
number = 1;
jump_back(number);
break;
case A_PERCENT: /* go to percent of file */
CMD_EXEC;
if (number < 0)
number = 0;
else if (number > 100)
number = 100;
jump_percent(number);
break;
case A_GOEND: /* go to line N, default end */
CMD_EXEC;
if (number <= 0)
jump_forw();
else
jump_back(number);
break;
case A_STAT: /* print file name, etc. */
longprompt = 1;
continue;
case A_QUIT: /* exit */
quit();
case A_F_SEARCH: /* search for a pattern */
case A_B_SEARCH:
if (number <= 0)
number = 1;
start_mca(action, (action==A_F_SEARCH) ? "/" : "?");
last_mca = mca;
wsearch = 1;
c = getcc();
if (c == '!') {
/*
* Invert the sense of the search; set wsearch
* to 0 and get a new character for the start
* of the pattern.
*/
start_mca(action,
(action == A_F_SEARCH) ? "!/" : "!?");
wsearch = 0;
c = getcc();
}
goto again;
case A_AGAIN_SEARCH: /* repeat previous search */
if (number <= 0)
number = 1;
if (wsearch)
start_mca(last_mca,
(last_mca == A_F_SEARCH) ? "/" : "?");
else
start_mca(last_mca,
(last_mca == A_F_SEARCH) ? "!/" : "!?");
CMD_EXEC;
(void)search(mca == A_F_SEARCH, (char *)NULL,
number, wsearch);
break;
case A_HELP: /* help */
lower_left();
clear_eol();
fputs("help", stdout);
CMD_EXEC;
help();
break;
case A_TAGFILE: /* tag a new file */
CMD_RESET;
start_mca(A_TAGFILE, "Tag: ");
c = getcc();
goto again;
case A_FILE_LIST: /* show list of file names */
CMD_EXEC;
showlist();
repaint();
break;
case A_EXAMINE: /* edit a new file */
CMD_RESET;
start_mca(A_EXAMINE, "Examine: ");
c = getcc();
goto again;
case A_VISUAL: /* invoke the editor */
if (ispipe) {
error("Cannot edit standard input");
break;
}
CMD_EXEC;
editfile();
ch_init(0, 0);
clr_linenum();
break;
case A_NEXT_FILE: /* examine next file */
if (number <= 0)
number = 1;
next_file(number);
break;
case A_PREV_FILE: /* examine previous file */
if (number <= 0)
number = 1;
prev_file(number);
break;
case A_SETMARK: /* set a mark */
lower_left();
clear_eol();
start_mca(A_SETMARK, "mark: ");
c = getcc();
if (c == erase_char || c == kill_char)
break;
setmark(c);
break;
case A_GOMARK: /* go to mark */
lower_left();
clear_eol();
start_mca(A_GOMARK, "goto mark: ");
c = getcc();
if (c == erase_char || c == kill_char)
break;
gomark(c);
break;
case A_PREFIX:
/*
* The command is incomplete (more chars are needed).
* Display the current char so the user knows what's
* going on and get another character.
*/
if (mca != A_PREFIX)
start_mca(A_PREFIX, "");
if (CONTROL_CHAR(c)) {
putchar('^');
c = CARAT_CHAR(c);
}
putchar(c);
c = getcc();
goto again;
default:
putchar('\7');
break;
}
}
}
int split_main(int argc UNUSED_PARAM, char **argv)
{
unsigned suffix_len = 2;
char *pfx;
char *count_p;
const char *sfx;
off_t cnt = 1000;
off_t remaining = 0;
unsigned opt;
ssize_t bytes_read, to_write;
char *src;
opt_complementary = "?2:a+"; /* max 2 args; -a N */
opt = getopt32(argv, "l:b:a:", &count_p, &count_p, &suffix_len);
if (opt & SPLIT_OPT_l)
cnt = XATOOFF(count_p);
if (opt & SPLIT_OPT_b) // FIXME: also needs XATOOFF
cnt = xatoull_sfx(count_p,
IF_FEATURE_SPLIT_FANCY(split_suffixes)
IF_NOT_FEATURE_SPLIT_FANCY(km_suffixes)
);
sfx = "x";
argv += optind;
if (argv[0]) {
int fd;
if (argv[1])
sfx = argv[1];
fd = xopen_stdin(argv[0]);
xmove_fd(fd, STDIN_FILENO);
} else {
argv[0] = (char *) bb_msg_standard_input;
}
if (NAME_MAX < strlen(sfx) + suffix_len)
bb_error_msg_and_die("suffix too long");
{
char *char_p = xzalloc(suffix_len + 1);
memset(char_p, 'a', suffix_len);
pfx = xasprintf("%s%s", sfx, char_p);
if (ENABLE_FEATURE_CLEAN_UP)
free(char_p);
}
while (1) {
bytes_read = safe_read(STDIN_FILENO, read_buffer, READ_BUFFER_SIZE);
if (!bytes_read)
break;
if (bytes_read < 0)
bb_simple_perror_msg_and_die(argv[0]);
src = read_buffer;
do {
if (!remaining) {
if (!pfx)
bb_error_msg_and_die("suffixes exhausted");
xmove_fd(xopen(pfx, O_WRONLY | O_CREAT | O_TRUNC), 1);
pfx = next_file(pfx, suffix_len);
remaining = cnt;
}
if (opt & SPLIT_OPT_b) {
/* split by bytes */
to_write = (bytes_read < remaining) ? bytes_read : remaining;
remaining -= to_write;
} else {
/* split by lines */
/* can be sped up by using _memrchr_
* and writing many lines at once... */
char *end = memchr(src, '\n', bytes_read);
if (end) {
--remaining;
to_write = end - src + 1;
} else {
to_write = bytes_read;
}
}
xwrite(STDOUT_FILENO, src, to_write);
bytes_read -= to_write;
src += to_write;
} while (bytes_read);
}
return EXIT_SUCCESS;
}
void chmod_cmd (void)
{
char buffer [BUF_TINY];
char *fname;
int i;
struct stat sf_stat;
Dlg_head *ch_dlg;
do { /* do while any files remaining */
ch_dlg = init_chmod ();
if (current_panel->marked)
fname = next_file (); /* next marked file */
else
fname = selection (current_panel)->fname; /* single file */
if (mc_stat (fname, &sf_stat) != 0) { /* get status of file */
destroy_dlg (ch_dlg);
break;
}
c_stat = sf_stat.st_mode;
mode_change = 0; /* clear changes flag */
/* set check buttons */
for (i = 0; i < PERMISSIONS; i++) {
check_perm[i].check->state = (c_stat & check_perm[i].mode) ? 1 : 0;
check_perm[i].selected = 0;
}
/* Set the labels */
c_fname = name_trunc (fname, 21);
add_widget (ch_dlg, label_new (FY+2, FX+2, c_fname));
c_fown = name_trunc (get_owner (sf_stat.st_uid), 21);
add_widget (ch_dlg, label_new (FY+6, FX+2, c_fown));
c_fgrp = name_trunc (get_group (sf_stat.st_gid), 21);
add_widget (ch_dlg, label_new (FY+8, FX+2, c_fgrp));
g_snprintf (buffer, sizeof (buffer), "%o", c_stat);
statl = label_new (FY+4, FX+2, buffer);
add_widget (ch_dlg, statl);
run_dlg (ch_dlg); /* retrieve an action */
/* do action */
switch (ch_dlg->ret_value) {
case B_ENTER:
if (mode_change)
if (mc_chmod (fname, c_stat) == -1)
message (1, MSG_ERROR, _(" Cannot chmod \"%s\" \n %s "),
fname, unix_error_string (errno));
need_update = 1;
break;
case B_CANCEL:
end_chmod = 1;
break;
case B_ALL:
case B_MARKED:
and_mask = or_mask = 0;
and_mask = ~and_mask;
for (i = 0; i < PERMISSIONS; i++) {
if (check_perm[i].selected || ch_dlg->ret_value == B_ALL) {
if (check_perm[i].check->state & C_BOOL)
or_mask |= check_perm[i].mode;
else
and_mask &= ~check_perm[i].mode;
}
}
apply_mask (&sf_stat);
break;
case B_SETMRK:
and_mask = or_mask = 0;
and_mask = ~and_mask;
for (i = 0; i < PERMISSIONS; i++) {
if (check_perm[i].selected)
or_mask |= check_perm[i].mode;
}
apply_mask (&sf_stat);
break;
case B_CLRMRK:
and_mask = or_mask = 0;
and_mask = ~and_mask;
for (i = 0; i < PERMISSIONS; i++) {
if (check_perm[i].selected)
and_mask &= ~check_perm[i].mode;
}
apply_mask (&sf_stat);
break;
}
if (current_panel->marked && ch_dlg->ret_value!=B_CANCEL) {
do_file_mark (current_panel, c_file, 0);
need_update = 1;
}
destroy_dlg (ch_dlg);
} while (current_panel->marked && !end_chmod);
chmod_done ();
}
/* send a request to the dive computer and collect the answer */
static bool uemis_get_answer(const char *path, char *request, int n_param_in,
int n_param_out, const char **error_text)
{
int i = 0, file_length;
char sb[BUFLEN];
char fl[13];
char tmp[101];
const char *what = translate("gettextFromC", "data");
bool searching = true;
bool assembling_mbuf = false;
bool ismulti = false;
bool found_answer = false;
bool more_files = true;
bool answer_in_mbuf = false;
char *ans_path;
int ans_file;
int timeout = UEMIS_LONG_TIMEOUT;
reqtxt_file = subsurface_open(reqtxt_path, O_RDWR | O_CREAT, 0666);
snprintf(sb, BUFLEN, "n%04d12345678", filenr);
str_append_with_delim(sb, request);
for (i = 0; i < n_param_in; i++)
str_append_with_delim(sb, param_buff[i]);
if (!strcmp(request, "getDivelogs") || !strcmp(request, "getDeviceData") || !strcmp(request, "getDirectory") ||
!strcmp(request, "getDivespot") || !strcmp(request, "getDive")) {
answer_in_mbuf = true;
str_append_with_delim(sb, "");
if (!strcmp(request, "getDivelogs"))
what = translate("gettextFromC", "divelog entry id");
else if (!strcmp(request, "getDivespot"))
what = translate("gettextFromC", "divespot data id");
else if (!strcmp(request, "getDive"))
what = translate("gettextFromC", "more data dive id");
}
str_append_with_delim(sb, "");
file_length = strlen(sb);
snprintf(fl, 10, "%08d", file_length - 13);
memcpy(sb + 5, fl, strlen(fl));
#if UEMIS_DEBUG & 1
fprintf(debugfile, "::w req.txt \"%s\"\n", sb);
#endif
if (write(reqtxt_file, sb, strlen(sb)) != strlen(sb)) {
*error_text = translate("gettextFromC", ERR_FS_SHORT_WRITE);
return false;
}
if (!next_file(number_of_files)) {
*error_text = translate("gettextFromC", ERR_FS_FULL);
more_files = false;
}
trigger_response(reqtxt_file, "n", filenr, file_length);
usleep(timeout);
mbuf = NULL;
mbuf_size = 0;
while (searching || assembling_mbuf) {
if (import_thread_cancelled)
return false;
progress_bar_fraction = filenr / 4000.0;
snprintf(fl, 13, "ANS%d.TXT", filenr - 1);
ans_path = build_filename(build_filename(path, "ANS"), fl);
ans_file = subsurface_open(ans_path, O_RDONLY, 0666);
read(ans_file, tmp, 100);
close(ans_file);
#if UEMIS_DEBUG & 8
tmp[100] = '\0';
fprintf(debugfile, "::t %s \"%s\"\n", ans_path, tmp);
#elif UEMIS_DEBUG & 4
char pbuf[4];
pbuf[0] = tmp[0];
pbuf[1] = tmp[1];
pbuf[2] = tmp[2];
pbuf[3] = 0;
fprintf(debugfile, "::t %s \"%s...\"\n", ans_path, pbuf);
#endif
free(ans_path);
if (tmp[0] == '1') {
searching = false;
if (tmp[1] == 'm') {
assembling_mbuf = true;
ismulti = true;
}
if (tmp[2] == 'e')
assembling_mbuf = false;
if (assembling_mbuf) {
if (!next_file(number_of_files)) {
*error_text = translate("gettextFromC", ERR_FS_FULL);
more_files = false;
assembling_mbuf = false;
}
reqtxt_file = subsurface_open(reqtxt_path, O_RDWR | O_CREAT, 0666);
trigger_response(reqtxt_file, "n", filenr, file_length);
}
} else {
if (!next_file(number_of_files - 1)) {
*error_text = translate("gettextFromC", ERR_FS_FULL);
more_files = false;
assembling_mbuf = false;
searching = false;
}
reqtxt_file = subsurface_open(reqtxt_path, O_RDWR | O_CREAT, 0666);
trigger_response(reqtxt_file, "r", filenr, file_length);
uemis_increased_timeout(&timeout);
}
if (ismulti && more_files && tmp[0] == '1') {
int size;
snprintf(fl, 13, "ANS%d.TXT", assembling_mbuf ? filenr - 2 : filenr - 1);
ans_path = build_filename(build_filename(path, "ANS"), fl);
ans_file = subsurface_open(ans_path, O_RDONLY, 0666);
size = bytes_available(ans_file);
if (size > 3) {
char *buf;
int r;
if (lseek(ans_file, 3, SEEK_CUR) == -1)
goto fs_error;
buf = malloc(size - 2);
if ((r = read(ans_file, buf, size - 3)) != size - 3) {
free(buf);
goto fs_error;
}
buf[r] = '\0';
buffer_add(&mbuf, &mbuf_size, buf);
show_progress(buf, what);
free(buf);
param_buff[3]++;
}
close(ans_file);
timeout = UEMIS_TIMEOUT;
usleep(UEMIS_TIMEOUT);
}
}
if (more_files) {
int size = 0, j = 0;
char *buf = NULL;
if (!ismulti) {
snprintf(fl, 13, "ANS%d.TXT", filenr - 1);
ans_path = build_filename(build_filename(path, "ANS"), fl);
ans_file = subsurface_open(ans_path, O_RDONLY, 0666);
size = bytes_available(ans_file);
if (size > 3) {
int r;
if (lseek(ans_file, 3, SEEK_CUR) == -1)
goto fs_error;
buf = malloc(size - 2);
if ((r = read(ans_file, buf, size - 3)) != size - 3) {
free(buf);
goto fs_error;
}
buf[r] = '\0';
buffer_add(&mbuf, &mbuf_size, buf);
show_progress(buf, what);
#if UEMIS_DEBUG & 8
fprintf(debugfile, "::r %s \"%s\"\n", ans_path, buf);
#endif
}
size -= 3;
close(ans_file);
free(ans_path);
} else {
ismulti = false;
}
#if UEMIS_DEBUG & 8
fprintf(debugfile, ":r: %s\n", buf);
#endif
if (!answer_in_mbuf)
for (i = 0; i < n_param_out && j < size; i++)
param_buff[i] = next_segment(buf, &j, size);
found_answer = true;
free(buf);
}
#if UEMIS_DEBUG & 1
for (i = 0; i < n_param_out; i++)
fprintf(debugfile, "::: %d: %s\n", i, param_buff[i]);
#endif
return found_answer;
fs_error:
close (ans_file);
return false;
}
void
chown_cmd (void)
{
char *fname;
struct stat sf_stat;
uid_t new_user;
gid_t new_group;
char buffer[BUF_TINY];
chown_i18n ();
do
{ /* do while any files remaining */
vfs_path_t *vpath;
WDialog *ch_dlg;
ch_dlg = init_chown ();
new_user = new_group = -1;
if (current_panel->marked)
fname = next_file (); /* next marked file */
else
fname = selection (current_panel)->fname; /* single file */
vpath = vfs_path_from_str (fname);
if (mc_stat (vpath, &sf_stat) != 0)
{ /* get status of file */
dlg_destroy (ch_dlg);
vfs_path_free (vpath);
break;
}
vfs_path_free (vpath);
/* select in listboxes */
listbox_select_entry (l_user, listbox_search_text (l_user, get_owner (sf_stat.st_uid)));
listbox_select_entry (l_group, listbox_search_text (l_group, get_group (sf_stat.st_gid)));
chown_label (0, str_trunc (fname, GW - 4));
chown_label (1, str_trunc (get_owner (sf_stat.st_uid), GW - 4));
chown_label (2, str_trunc (get_group (sf_stat.st_gid), GW - 4));
size_trunc_len (buffer, GW - 4, sf_stat.st_size, 0, panels_options.kilobyte_si);
chown_label (3, buffer);
chown_label (4, string_perm (sf_stat.st_mode));
switch (dlg_run (ch_dlg))
{
case B_CANCEL:
end_chown = 1;
break;
case B_SETUSR:
{
struct passwd *user;
char *text;
listbox_get_current (l_user, &text, NULL);
user = getpwnam (text);
if (user)
{
new_user = user->pw_uid;
apply_chowns (new_user, new_group);
}
break;
}
case B_SETGRP:
{
struct group *grp;
char *text;
listbox_get_current (l_group, &text, NULL);
grp = getgrnam (text);
if (grp)
{
new_group = grp->gr_gid;
apply_chowns (new_user, new_group);
}
break;
}
case B_SETALL:
case B_ENTER:
{
struct group *grp;
struct passwd *user;
char *text;
listbox_get_current (l_group, &text, NULL);
grp = getgrnam (text);
if (grp)
new_group = grp->gr_gid;
listbox_get_current (l_user, &text, NULL);
user = getpwnam (text);
if (user)
new_user = user->pw_uid;
if (ch_dlg->ret_value == B_ENTER)
{
vfs_path_t *fname_vpath;
fname_vpath = vfs_path_from_str (fname);
need_update = 1;
if (mc_chown (fname_vpath, new_user, new_group) == -1)
message (D_ERROR, MSG_ERROR, _("Cannot chown \"%s\"\n%s"),
fname, unix_error_string (errno));
vfs_path_free (fname_vpath);
}
else
apply_chowns (new_user, new_group);
break;
}
} /* switch */
if (current_panel->marked && ch_dlg->ret_value != B_CANCEL)
{
do_file_mark (current_panel, current_file, 0);
need_update = 1;
}
dlg_destroy (ch_dlg);
}
while (current_panel->marked && !end_chown);
chown_done ();
}