ssize_t NetStream::write_to_net( const void *buf, size_t nbytes ) const { set_blocking(true); #ifdef WIN32 ssize_t bytes_written = write_win32(_fd, buf, nbytes); #else ssize_t bytes_written = ::write(_fd, buf, nbytes); #endif set_blocking(false); if (bytes_written < 0 || NET_exception) { perror("NetStream::write_to_net: Warning: "); NET_exception = 0; } else if (bytes_written < (ssize_t)nbytes) cerr << "Couldn't flush the buffer. Some data wasn't written. (nbytes=" << nbytes << " written=" << bytes_written << ")\n"; return bytes_written; }
ssize_t timed_read(int sockfd, void* buf, size_t count, int timeout_ms) { ssize_t rv; set_non_blocking(sockfd); do { if (0 <= (rv = wait_fd(sockfd, timeout_ms))) rv = read(sockfd, buf, count); } while (errno == EINTR); set_blocking(sockfd); return rv; }
static BOOL open_sockets(BOOL isdaemon, int port) { /* * The sockets opened here will be used to receive broadcast * packets *only*. Interface specific sockets are opened in * make_subnet() in namedbsubnet.c. Thus we bind to the * address "0.0.0.0". The parameter 'socket address' is * now deprecated. */ if ( isdaemon ) ClientNMB = open_socket_in(SOCK_DGRAM, port, 0, interpret_addr(lp_socket_address()), True); else ClientNMB = 0; ClientDGRAM = open_socket_in(SOCK_DGRAM, DGRAM_PORT, 3, interpret_addr(lp_socket_address()), True); if ( ClientNMB == -1 ) return( False ); #ifndef _XBOX /* we are never interested in SIGPIPE */ BlockSignals(True,SIGPIPE); #endif set_socket_options( ClientNMB, "SO_BROADCAST" ); set_socket_options( ClientDGRAM, "SO_BROADCAST" ); /* Ensure we're non-blocking. */ set_blocking( ClientNMB, False); set_blocking( ClientDGRAM, False); DEBUG( 3, ( "open_sockets: Broadcast sockets opened.\n" ) ); return( True ); }
/** * Opens and initializes a serial port. */ int serial_create (char *device) { int fd = open(device, O_RDWR | O_NOCTTY | O_SYNC | O_NDELAY); if (fd < 0) { printf("error %d opening '%s', %s\n", errno, device, strerror(errno)); goto exit; } set_interface_attribs(fd, B19200, 0); set_blocking(fd, 0); exit: return fd; }
static NTSTATUS unixdom_listen(struct socket_context *sock, const struct socket_address *my_address, int queue_size, uint32_t flags) { struct sockaddr_un my_addr; int ret; /* delete if it already exists */ if (my_address->addr) { unlink(my_address->addr); } if (my_address->sockaddr) { ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr)); } else if (my_address->addr == NULL) { return NT_STATUS_INVALID_PARAMETER; } else { if (strlen(my_address->addr)+1 > sizeof(my_addr.sun_path)) { return NT_STATUS_OBJECT_PATH_INVALID; } ZERO_STRUCT(my_addr); my_addr.sun_family = AF_UNIX; snprintf(my_addr.sun_path, sizeof(my_addr.sun_path), "%s", my_address->addr); ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr)); } if (ret == -1) { return unixdom_error(errno); } if (sock->type == SOCKET_TYPE_STREAM) { ret = listen(sock->fd, queue_size); if (ret == -1) { return unixdom_error(errno); } } if (!(flags & SOCKET_FLAG_BLOCK)) { ret = set_blocking(sock->fd, false); if (ret == -1) { return unixdom_error(errno); } } sock->state = SOCKET_STATE_SERVER_LISTEN; sock->private_data = (void *)talloc_strdup(sock, my_address->addr); return NT_STATUS_OK; }
int main(int argc, char **argv){ char *portname0 = "/dev/ttyUSB1"; char *portname1 = "/dev/ttyUSB0"; int fd0 = open(portname0, O_RDWR | O_NOCTTY | O_SYNC); if (fd0 < 0) { fprintf(stderr, "error %d opening %s: %s", errno, portname0, strerror(errno)); return; } set_interface_attribs(fd0, B9600, 0); //B115200 set_blocking(fd0, 0); write(fd0, "hello!\n", 7); printf("hello!\n"); usleep((7+25)*1000); close(fd0); char buf[100]; int fd1 = open(portname1, O_RDWR | O_NOCTTY | O_SYNC); if (fd1 < 0) { fprintf(stderr, "error %d opening %s: %s", errno, portname1, strerror(errno)); return; } set_interface_attribs(fd1, B9600, 0); set_blocking(fd1, 0); int n = read(fd1, buf, sizeof buf); printf("%s",buf); close(fd1); return 0; }
void Socket::create(Socket::Handle handle) { if (handle_ == priv::SocketImpl::invalid()) { int op_value = 1; handle_ = handle; set_blocking(blocking_); if (setsockopt(handle_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char*>(&op_value), sizeof(op_value)) == -1) { // throw Exception("Failed to set socket option TCP_NODELAY"); return; } } }
int initializeSerialPort(char *portname) { int fd = open (portname, O_RDWR | O_NOCTTY | O_SYNC); printf("FD OPEN, fd = %d", fd); if (fd < 0) { printf("error %d opening %s: %s", errno, portname, strerror (errno)); return -1; } set_interface_attribs (fd, B9600, 0); // set speed to 115,200 bps, 8n1 (no parity) set_blocking (fd, 0); // set no blocking return fd; }
int initMW(void) { int fd = open (MINDWAVEPORT, O_RDWR | O_NOCTTY | O_SYNC); if (fd < 0) { fprintf (stderr, "error %d opening %s: %s\n", errno, MINDWAVEPORT, strerror (errno)); exit (1); } set_interface_attribs (fd, B57600, 0); // 57,600 bps, 8n1 (no parity) set_blocking (fd, 0); // set non blocking return (fd); }
static int Connect (int fd, SA *addr) { int retval; set_non_blocking(fd); if ((retval = connect(fd, addr, socklen(addr)))) { if (errno != EINPROGRESS) syserr(-1, "Connect: connect(%d) failed: %s", fd, strerror(errno)); else retval = 0; } set_blocking(fd); return retval; }
int initSerial( int *fd, int baudrate, char *devname ) { *fd = open( devname, O_RDWR | O_NOCTTY | O_SYNC ); if (*fd < 0) { fprintf(stderr, "! ERROR: Could not open serial port!\n"); perror("! ERROR Message from system"); return EXIT_FAILURE; } set_interface_attribs (*fd, baudrate, 0); // set speed to 115,200 bps, 8n1 (no parity) set_blocking (*fd, 0); // set no blockin return EXIT_SUCCESS; }
/* note that for simplicity of the API, socket_listen() is also use for DGRAM sockets, but in reality only a bind() is done */ static NTSTATUS ipv4_listen(struct socket_context *sock, const struct socket_address *my_address, int queue_size, uint32_t flags) { struct sockaddr_in my_addr; struct in_addr ip_addr; int ret; socket_set_option(sock, "SO_REUSEADDR=1", NULL); if (my_address->sockaddr) { ret = bind(sock->fd, my_address->sockaddr, my_address->sockaddrlen); } else { ip_addr = interpret_addr2(my_address->addr); ZERO_STRUCT(my_addr); #ifdef HAVE_SOCK_SIN_LEN my_addr.sin_len = sizeof(my_addr); #endif my_addr.sin_addr.s_addr = ip_addr.s_addr; my_addr.sin_port = htons(my_address->port); my_addr.sin_family = PF_INET; ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr)); } if (ret == -1) { return map_nt_error_from_unix_common(errno); } if (sock->type == SOCKET_TYPE_STREAM) { ret = listen(sock->fd, queue_size); if (ret == -1) { return map_nt_error_from_unix_common(errno); } } if (!(flags & SOCKET_FLAG_BLOCK)) { ret = set_blocking(sock->fd, false); if (ret == -1) { return map_nt_error_from_unix_common(errno); } } sock->state= SOCKET_STATE_SERVER_LISTEN; return NT_STATUS_OK; }
static NTSTATUS ipv6_tcp_accept(struct socket_context *sock, struct socket_context **new_sock) { struct sockaddr_in6 cli_addr; socklen_t cli_addr_len = sizeof(cli_addr); int new_fd; if (sock->type != SOCKET_TYPE_STREAM) { return NT_STATUS_INVALID_PARAMETER; } new_fd = accept(sock->fd, (struct sockaddr *)&cli_addr, &cli_addr_len); if (new_fd == -1) { return map_nt_error_from_unix_common(errno); } if (!(sock->flags & SOCKET_FLAG_BLOCK)) { int ret = set_blocking(new_fd, false); if (ret == -1) { close(new_fd); return map_nt_error_from_unix_common(errno); } } /* TODO: we could add a 'accept_check' hook here * which get the black/white lists via socket_set_accept_filter() * or something like that * --metze */ (*new_sock) = talloc(NULL, struct socket_context); if (!(*new_sock)) { close(new_fd); return NT_STATUS_NO_MEMORY; } /* copy the socket_context */ (*new_sock)->type = sock->type; (*new_sock)->state = SOCKET_STATE_SERVER_CONNECTED; (*new_sock)->flags = sock->flags; (*new_sock)->fd = new_fd; (*new_sock)->private_data = NULL; (*new_sock)->ops = sock->ops; (*new_sock)->backend_name = sock->backend_name; return NT_STATUS_OK; }
//Open the serial port file descriptor int openSerial(){ char *portname = "/dev/ttyMCC"; // Open serial port (file descriptor) int fd = open (portname, O_RDWR | O_NOCTTY | O_SYNC); if (fd < 0) { printf("error %d opening %s: %s", errno, portname, strerror (errno)); return 0; } // Configure the serial communication interface before use set_interface_attribs (fd, B115200, 0); // set speed to 115,200 bps, 8n1 (no parity) set_blocking (fd, 0); // set no blocking return fd; }
/** sms **/ static void * sms_thread (void * arg) { struct smsnode * tmp, * sq = ((struct thrdarg *) arg)->sq; char ttyb[64]; int tty, ttyr, ttyw; while (1) { sq = sq->next; if (sq->status == CRYPTO_SMS_STATUS_HOME) continue; if (sq->status == CRYPTO_SMS_STATUS_SENT) { printf ("sms sent. leaving queue %s\n", sq->number); tmp = sq; sq->prev->next = sq->next; sq->next->prev = sq->prev; sq = sq->prev; free (tmp->key); free (tmp->number); free (tmp); } if (sq->status == CRYPTO_SMS_STATUS_PENDING) { printf ("sending sms key %s\nto number %s\n", sq->key, sq->number); tty = open ("/dev/ttyUSB0", O_RDWR | O_NOCTTY | O_NDELAY); if (tty < 0) continue; set_serial (tty, B2400, 0); set_blocking (tty, B9600, 0); ttyw = write (tty, "AT+CMGF=1\r\n", 11); printf ("ttyw=%d\n", ttyw); sleep (1); sprintf (ttyb, "AT+CMGS=\"%s\"\r%s%c", sq->number, sq->key, (char) 26); ttyw = write (tty, ttyb, strlen(ttyb)); printf ("ttyb=%s,\n", ttyb); printf ("ttyw=%d\n", ttyw); sleep (1); close (tty); sq->status = CRYPTO_SMS_STATUS_SENT; } if (sq->status == CRYPTO_SMS_STATUS_ERROR) { tmp = sq; sq->prev->next = sq->next; sq->next->prev = sq->prev; sq = sq->prev; free (tmp); } } }
_PUBLIC_ NTSTATUS socket_create_with_ops(TALLOC_CTX *mem_ctx, const struct socket_ops *ops, struct socket_context **new_sock, enum socket_type type, uint32_t flags) { NTSTATUS status; (*new_sock) = talloc(mem_ctx, struct socket_context); if (!(*new_sock)) { return NT_STATUS_NO_MEMORY; } (*new_sock)->type = type; (*new_sock)->state = SOCKET_STATE_UNDEFINED; (*new_sock)->flags = flags; (*new_sock)->fd = -1; (*new_sock)->private_data = NULL; (*new_sock)->ops = ops; (*new_sock)->backend_name = NULL; status = (*new_sock)->ops->fn_init((*new_sock)); if (!NT_STATUS_IS_OK(status)) { talloc_free(*new_sock); return status; } /* by enabling "testnonblock" mode, all socket receive and send calls on non-blocking sockets will randomly recv/send less data than requested */ if (!(flags & SOCKET_FLAG_BLOCK) && type == SOCKET_TYPE_STREAM && getenv("SOCKET_TESTNONBLOCK") != NULL) { (*new_sock)->flags |= SOCKET_FLAG_TESTNONBLOCK; } /* we don't do a connect() on dgram sockets, so need to set non-blocking at socket create time */ if (!(flags & SOCKET_FLAG_BLOCK) && type == SOCKET_TYPE_DGRAM) { set_blocking(socket_get_fd(*new_sock), false); } talloc_set_destructor(*new_sock, socket_destructor); return NT_STATUS_OK; }
int openPort(char* portname, int speed, int vmin, int vtime) { printf("trying to open port %s\n", portname); int fd = open (portname, O_RDWR | O_NOCTTY | O_SYNC); if (fd < 0) { printf("error %d opening %s: %s\n", errno, portname, strerror (errno)); return; } set_interface_attribs (fd, speed, 0); set_blocking (fd, vmin, vtime); return fd; }
static int read_from_sd ( int sd ) { char buf[100]; int n; set_blocking(sd); n = read(sd, buf, 99); if (n <= 0) return 0; /* closed */ copyout(buf, n); set_nonblocking(sd); while (1) { n = read(sd, buf, 100); if (n <= 0) return 1; /* not closed */ copyout(buf, n); } }
int main(void) { char *portname = "/dev/ttymxc3"; int fd = open (portname, O_RDWR | O_NOCTTY | O_SYNC); if (fd < 0) { printf("error %d opening %s: %s", errno, portname, strerror (errno)); return; } set_interface_attribs (fd, B115200, 0); // set speed to 115,200 bps, 8n1 (no parity) set_blocking (fd, 0); // set no blocking char buf [7]; int n; char buffON[2] = {13,1}; write(fd, buffON, 2); // send 2 character greeting sleep(1); // delay 1 second n = read (fd, buf, sizeof buf); // read up to 7 characters if ready to read if (n > 0) { //printf("quanti: %d\n", n); int i; for (i = 0; i < n; i++) { printf("%c",buf[i]); } } char buffOFF[2] = {13,0}; write(fd, buffOFF, 2); sleep(1); // delay 1 second n = read (fd, buf, sizeof buf); // read up to 7 characters if ready to read if (n > 0) { //printf("quanti: %d\n", n); int i; for (i = 0; i < n; i++) { printf("%c",buf[i]); } } }
static NTSTATUS unixdom_accept(struct socket_context *sock, struct socket_context **new_sock) { struct sockaddr_un cli_addr; socklen_t cli_addr_len = sizeof(cli_addr); int new_fd; if (sock->type != SOCKET_TYPE_STREAM) { return NT_STATUS_INVALID_PARAMETER; } new_fd = accept(sock->fd, (struct sockaddr *)&cli_addr, &cli_addr_len); if (new_fd == -1) { return unixdom_error(errno); } if (!(sock->flags & SOCKET_FLAG_BLOCK)) { int ret = set_blocking(new_fd, false); if (ret == -1) { close(new_fd); return map_nt_error_from_unix_common(errno); } } smb_set_close_on_exec(new_fd); (*new_sock) = talloc(NULL, struct socket_context); if (!(*new_sock)) { close(new_fd); return NT_STATUS_NO_MEMORY; } /* copy the socket_context */ (*new_sock)->type = sock->type; (*new_sock)->state = SOCKET_STATE_SERVER_CONNECTED; (*new_sock)->flags = sock->flags; (*new_sock)->fd = new_fd; (*new_sock)->private_data = NULL; (*new_sock)->ops = sock->ops; (*new_sock)->backend_name = sock->backend_name; return NT_STATUS_OK; }
int main(int argc, char **argv) { fd = open (portname, O_RDWR | O_NOCTTY | O_SYNC); if (fd < 0) { printf("error %d opening %s: %s", errno, portname, strerror (errno)); return; } set_interface_attribs (fd, B115200, 0); // set speed to 115,200 bps, 8n1 (no parity) set_blocking (fd, 0); // set no blocking if(argc == 2){ if(strcmp(argv[1], "red") == 0) sendcmd(254, 0, 0); else if(strcmp(argv[1], "green")== 0) sendcmd(0, 254, 0); else if(strcmp(argv[1], "blue")== 0) sendcmd(0, 0, 254); else if(strcmp(argv[1], "yellow")== 0) sendcmd(254, 254, 0); else if(strcmp(argv[1], "pink")== 0) sendcmd(254, 0, 254); else if(strcmp(argv[1], "cyan")== 0) sendcmd(0, 254, 254); else if(strcmp(argv[1], "black")== 0) sendcmd(0, 0, 0); else if(strcmp(argv[1], "white")== 0) sendcmd(254, 254, 254); else printf("\nUnknown argument\n"); } else if(argc == 4){ sendcmd(atoi(argv[0]), atoi(argv[1]),atoi(argv[2])); } else{ printf("GionjiLed\n"); printf("Usage:\n"); printf("gionjiled [red | green | blue | yellow | pink | cyan | white | black]\n"); printf("gionjiled R G B [from 0 to 254]\n"); printf("Enjoy"); } }
static NTSTATUS get_ldapi_ctx(TALLOC_CTX *mem_ctx, struct tldap_context **pld) { struct tldap_context *ld; struct sockaddr_un addr; char *sockaddr; int fd; NTSTATUS status; int res; sockaddr = talloc_asprintf(talloc_tos(), "/%s/ldap_priv/ldapi", lp_private_dir()); if (sockaddr == NULL) { DEBUG(10, ("talloc failed\n")); return NT_STATUS_NO_MEMORY; } ZERO_STRUCT(addr); addr.sun_family = AF_UNIX; strncpy(addr.sun_path, sockaddr, sizeof(addr.sun_path)); TALLOC_FREE(sockaddr); status = open_socket_out((struct sockaddr_storage *)(void *)&addr, 0, 0, &fd); if (!NT_STATUS_IS_OK(status)) { DEBUG(10, ("Could not connect to %s: %s\n", addr.sun_path, nt_errstr(status))); return status; } set_blocking(fd, false); ld = tldap_context_create(mem_ctx, fd); if (ld == NULL) { close(fd); return NT_STATUS_NO_MEMORY; } res = tldap_fetch_rootdse(ld); if (res != TLDAP_SUCCESS) { DEBUG(10, ("tldap_fetch_rootdse failed: %s\n", tldap_errstr(talloc_tos(), ld, res))); TALLOC_FREE(ld); return NT_STATUS_LDAP(res); } *pld = ld; return NT_STATUS_OK;; }
pid_t piped_child_http(char **command) { pid_t pid; pid = do_fork(); if (pid == -1) { rsyserr(FERROR, errno, "fork"); exit_cleanup(RERR_IPC); } if (pid == 0) { set_blocking(STDIN_FILENO); execvp(command[0], command); rsyserr(FERROR, errno, "Failed to exec %s", command[0]); exit_cleanup(RERR_IPC); } return pid; }
// Initialise serial cable and run one time setup bool application_init(void) { char *portname = "/dev/ttyUSB0"; fd = open (portname, O_RDWR | O_NOCTTY | O_SYNC); if (fd < 0) { NABTO_LOG_INFO(("error %d opening %s: %s\n", errno, portname, strerror (errno))); return 0; } else { NABTO_LOG_INFO(("Opening %s: %s\n", portname, strerror (errno))); } set_interface_attribs (fd, B115200, 0); // set speed to 115,200 bps, 8n1 (no parity) set_blocking (fd, 0); // set no blocking // Wake Roomba setRTS(fd, 0); usleep(100000); //0.1 sec setRTS(fd, 1); sleep(2); // Songs can be defined while in passive mode (which we are in right now) char DSB[] = {140, 0, 3, 74, 40, 75, 20, 70, 32}; write(fd, &DSB, sizeof(DSB)); usleep ((sizeof(DSB)+25) * 100); char reverse[] = {140, 1, 6, 84, 32, 30, 32, 84, 32, 30, 32, 84, 32, 30, 32}; write(fd, &reverse, sizeof(reverse)); usleep ((sizeof(reverse)+25) * 100); char car_low[] = {140, 2, 12, 74,10, 71,10, 67,10, 67,10, 67,10, 69,10, 71,10, 72,10, 74,10, 74,10, 74,10, 71,10}; write(fd, &car_low, sizeof(car_low)); usleep ((sizeof(car_low)+25) * 100); char car_high[] = {140, 3, 12, 86,10, 83,10, 79,10, 79,10, 79,10, 81,10, 83,10, 84,10, 86,10, 86,10, 86,10, 83,10}; write(fd, &car_high, sizeof(car_high)); usleep ((sizeof(car_high)+25) * 100); return 1; }
void client_connection_cb(int sd, short type, void *arg) { int nsd; if ((nsd = accept(sd, NULL, NULL)) < 0) { if (errno == EWOULDBLOCK || errno == ECONNABORTED) return; else btpd_err("client accept: %s\n", strerror(errno)); } if ((errno = set_blocking(nsd)) != 0) btpd_err("set_blocking: %s.\n", strerror(errno)); struct cli *cli = btpd_calloc(1, sizeof(*cli)); cli->sd = nsd; btpd_ev_new(&cli->read, cli->sd, EV_READ, cli_read_cb, cli); }
int read_port() { char *portname = "/dev/ttyACM0"; int fd = open (portname, O_RDWR | O_NOCTTY | O_SYNC); if (fd < 0) { printf("error %d opening %s: %s", errno, portname, strerror (errno)); return(0); } set_interface_attribs (fd, B9600, 0); // set speed to 9600 bps, 8n1 (no parity) set_blocking (fd, 0); // set no blocking write (fd, "hello!\n", 7); // send 7 character greeting char buf [100]; int n = read (fd, buf, sizeof buf); // read up to 100 characters if ready to read printf("data is:",fd); }
int _open_serial_connection(char *name, char *baudrate_arg) { unsigned baudrate = 0; if (_parse_baudrate(baudrate_arg, &baudrate) == -1) { fprintf(stderr, "Invalid baudrate specified: %s\n", baudrate_arg); return 1; } int serial_fd = open(name, O_RDWR | O_NOCTTY | O_SYNC); if (serial_fd < 0) { fprintf(stderr, "Error opening serial device %s\n", name); return -1; } set_serial_attribs(serial_fd, baudrate, 0); set_blocking(serial_fd, 1); return serial_fd; }
int KeypadController::setup() { fd = open(keypadname.toLocal8Bit().data(), O_RDWR); //Sets FD to open said port if (fd < 0) //If Statement produces error message if selected port cannot be opened { qDebug() << "error" << errno << " opening " << keypadname << strerror(errno); return 1; } set_interface_attribs(B115200, 0); // set speed to 115,200 bps, 8n1 (no parity) set_blocking(0); // Set up Ports on PIO sendToKeypad("@00D000\r"); // Sets Port A to output // qDebug() << response; sendToKeypad("@00D1FF\r"); // Sets Port B to input // qDebug() << response; sendToKeypad("@00D200\r"); // Sets Port C to output // qDebug() << response; return 0; }
int serial_init(int* fd,const char* seriale_dev) { /* apro la porta seriale*/ const char * portname = seriale_dev; *fd = open(portname, O_RDWR | O_NOCTTY | O_SYNC); if (*fd < 0) { printf("error %d opening %s: %s", errno, portname, strerror (errno)); return -1; } /*imposto baud rate*/ set_interface_attribs (*fd, B115200, 0); // set speed to 115,200 bps, 8n1 (no parity) set_blocking (*fd, 0); return 1; }
int main() { rs232_fd = open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY); if (rs232_fd < 0) { fprintf(stderr, "RS232 error\n"); exit(1); } set_interface_attribs(rs232_fd, B115200, 0); set_blocking(rs232_fd, 0); write(rs232_fd, "PCready\n", 8); printf("READY\n"); while(1) { int array[2]; array[0] = 0, array[1] = 1; toggle_sound(array, 2, 1); usleep(10000000); } /* while(1) { fprintf(rs232, "PC ready\n"); fgets(buffer, 10000, rs232); if (strcmp(buffer, "DE2 ready") == 0) { break; } } */ /* int mode; scanf("%d", &n); switch (mode) { case 1: break; case 2: break; } */ return 0; }