The read() system call needs to be run in a loop to deal safely with edge cases that can appear on some system configurations. Some libraries provide a function for this (for example the C library [fread), but it is not too hard to code yourself. Consider the following snippet of code, with two parts replaced by XXX and YYY ssize_t do_read(int fd, void sbuffer, size_t len) { ssize_t res; do ( res read(fd, buf, len); while (res xxx @ && errno YYY); return res; } Enter the values for XXX and YYY to make this code run correctly, respecting the following rules. The correct value for XXX is a single operator. Enter it without any spaces. The correct value for YWY is a clause to do a comparison with the errno value. Enter the value with no leading or trailing spaces, and exactly one space in any places inside the string where spaces are required. Enter the values here: ● XXX: • YYY:

The read() system call needs to be run in a loop to deal safely with edge cases that can appear on some system configurations. Some libraries provide a function for this (for example the C library [fread), but it is not too hard to code yourself. Consider the following snippet of code, with two parts replaced by XXX and YYY ssize_t do_read(int fd, void sbuffer, size_t len) { ssize_t res; do ( res read(fd, buf, len); while (res xxx @ && errno YYY); return res; } Enter the values for XXX and YYY to make this code run correctly, respecting the following rules. The correct value for XXX is a single operator. Enter it without any spaces. The correct value for YWY is a clause to do a comparison with the errno value. Enter the value with no leading or trailing spaces, and exactly one space in any places inside the string where spaces are required. Enter the values here: ● XXX: • YYY:

Database System Concepts

7th Edition

ISBN:9780078022159

Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Chapter1: Introduction

Section: Chapter Questions

Problem 1PE

See similar textbooks

Similar questions

The goal of this second exercise is to develop a better understanding of the Linuxinterprocess communication mechanisms. This would require you to write twoprograms P1 and P2. The first program P1 needs to generate an array of 50random strings (of characters) of fixed length each. P1 then sends a group offive consecutive elements of the array of strings to P2 along with the ID’s ofthe strings, where the ID is the index of the array corresponding to the string.The second program P2 needs to accept the received strings, and send backthe highest ID received back to P1 to acknowledge the strings received. Theprogram P2 simply prints the ID’s and the strings on the console. On receivingthe acknowledged packet, P1 sends the next five strings, with the string elementsstarting from the successor of the acknowledged ID. The above mechanism needs to be implemented FIFO and UNIX DOMAIN SOCKETS. Please note that you may NOT make assumptions about the reliability of the interprocess communication…
Is there a special reason why the symbol or name used in the C++ inclusion guard on a library interface file has to be special? A helpful tactic in this situation is to use proof by contradiction: assume that the symbol doesn't need to be unique, and then show what happens when two libraries that are both #included in the same application use the same symbol.
Why does the C++ inclusion guard on a library interface file need a unique symbol or name? Assume that the symbol does not need to be unique and then show what happens when two libraries that are to be #included in the same application both use the same symbol. This is an example of proof by contradiction.
To what end does it matter if the symbol or name used in the C++ inclusion guard on a library interface file be distinct? By assuming that the symbol doesn't need to be unique, and then showing what happens when two libraries that are to be #included in the same application both use the same symbol, we have a helpful proof by contradiction approach at our disposal.
When using a C++ inclusion guard on a library interface file, why is it essential that the symbol or name used in the guard not be identical to any other uses of the symbol or name in the guard? Assuming that the symbol does not need to be unique and then showing what occurs when two libraries that are to be #included in the same application share the same symbol is an effective use of the proof by contradiction technique in this circumstance. Here, we have an actual application.
write in C your own static library for dynamic allocation of memory (library should allocate and deallocate) using freelists and mmap and commands for executing this in Linux?
I'm having a hard time seeing the problem with this buffer overflow problem can someone please elaborate if its secure or not, and if there are any other issues with the implementation in the problem? Someone tries to fix the stack based buffer overflow problem as follows, is it secure now? why? Are there any other issues within the function's implementation below? Explain your reasoning. int bof(char *str, int size) { char *buffer = (char *) malloc(size); strcpy(buffer, str); return 1; }
Modify the producer-consumer implementation code bellow, so that it uses monitors to handle race conditions instead of semaphores or mutexes. Use the pthread library implementation #include <pthread.h> #include <semaphore.h> #include <stdio.h> #include <stdlib.h> #define BUFFER_SIZE 20 pthread_mutex_t mutex; int count = 0; int buffer[BUFFER_SIZE]; pthread_t tid; int producers = 0, consumers = 0; void insert(int item) { while (count == BUFFER_SIZE); if (count < BUFFER_SIZE) { buffer[producers] = item; producers++; producers=producers%BUFFER_SIZE; sleep(1); } return; } int remove_item() { int item; while (count == 0); if (count > 0) { item = buffer[consumers]; buffer[consumers] = buffer[consumers - 1]; consumers++; consumers=consumers%BUFFER_SIZE; sleep(1); } return item; } void * producer(void *param) { int item; while (1) { item = rand() % BUFFER_SIZE; while (count >= BUFFER_SIZE);…
Write a c++ code that compare the times to traverse a list (containing a large number of elements) implemented in an array, in a simple linked list, and in an unrolled linked list. In this experiment, you need to generate a large list, store it in each representation, and then measure the time to traverse the list in each representation. For the array, this is almost straightforward: Fill the array and then do a sequential scan. Here is the thing to watch for: When you fill the array, it all gets read into cache. So, somehow you need to ensure that almost all of the array is NOT in cache before you do your traversal. One thing you can do is make your array big enough that most of it will not fit in cache at once. You need to make sure that the node capacity is not too small, or it will behave too much like a simple linked list.
Someone tries to fix the stack based buffer overflow problem as follows, is it secure now? why? Are there any other issues within the function's implementation below? int bof(char *str, int size) { char *buffer = (char *) malloc(size); strcpy(buffer, str); return 1; }
Why must a library interface file's inclusion guard symbol or name be distinct? To demonstrate what happens when two libraries #included in the same program share the same symbol, utilize the proof by contradiction technique.
Write a C program that will start in a provided directory path, and from there recursively visit all folders, generating an output that dot can read which we can then use to create a pretty output tree showing the directory structure. Each node on the graph should be a directory/file in your filesystem, and include: file/directory name File size Number of allocated blocks i-node number number of links