v/vlib/os/os_nix.c.v

272 lines
5.0 KiB
V
Raw Normal View History

module os
2019-07-01 17:04:09 +02:00
2020-02-03 04:01:39 +01:00
import strings
2019-07-01 17:04:09 +02:00
#include <dirent.h>
#include <unistd.h>
2020-01-21 16:58:47 +01:00
#include <fcntl.h>
2020-06-14 15:46:30 +02:00
#include <sys/utsname.h>
2019-10-24 11:36:57 +02:00
pub const (
2019-10-12 21:18:19 +02:00
path_separator = '/'
2020-05-26 03:17:52 +02:00
path_delimiter = ':'
)
2019-12-31 08:53:53 +01:00
const (
2020-07-21 15:28:30 +02:00
stdin_value = 0
2019-12-31 08:53:53 +01:00
stdout_value = 1
2020-01-05 20:13:35 +01:00
stderr_value = 2
2019-12-31 08:53:53 +01:00
)
2020-06-14 15:46:30 +02:00
struct C.utsname {
mut:
sysname charptr
nodename charptr
release charptr
version charptr
machine charptr
}
fn C.uname(name voidptr) int
2020-07-21 15:28:30 +02:00
fn C.symlink(charptr, charptr) int
2019-12-27 19:10:06 +01:00
2020-06-14 15:46:30 +02:00
pub fn uname() Uname {
mut u := Uname{}
2020-07-21 15:28:30 +02:00
utsize := sizeof(C.utsname)
x := malloc(int(utsize))
d := &C.utsname(x)
2020-06-14 15:46:30 +02:00
if C.uname(d) == 0 {
2020-07-14 00:16:31 +02:00
u.sysname = cstring_to_vstring(byteptr(d.sysname))
u.nodename = cstring_to_vstring(byteptr(d.nodename))
u.release = cstring_to_vstring(byteptr(d.release))
u.version = cstring_to_vstring(byteptr(d.version))
u.machine = cstring_to_vstring(byteptr(d.machine))
2020-06-14 15:46:30 +02:00
}
free(d)
return u
}
2020-05-05 15:26:42 +02:00
fn init_os_args(argc int, argv &&byte) []string {
mut args := []string{}
2020-07-21 15:28:30 +02:00
// mut args := []string(make(0, argc, sizeof(string)))
// mut args := []string{len:argc}
2019-10-13 00:50:15 +02:00
for i in 0 .. argc {
// args [i] = argv[i].vstring()
unsafe {
args << byteptr(argv[i]).vstring()
}
2019-11-29 17:14:26 +01:00
}
2019-09-14 22:48:30 +02:00
return args
}
2019-10-17 13:30:05 +02:00
pub fn ls(path string) ?[]string {
mut res := []string{}
2020-07-14 00:16:31 +02:00
dir := C.opendir(charptr(path.str))
2019-08-16 14:05:11 +02:00
if isnil(dir) {
2019-10-17 13:30:05 +02:00
return error('ls() couldnt open dir "$path"')
2019-08-16 14:05:11 +02:00
}
2019-12-04 10:19:32 +01:00
mut ent := &C.dirent(0)
2019-12-19 22:29:37 +01:00
// mut ent := &C.dirent{!}
2019-08-16 14:05:11 +02:00
for {
ent = C.readdir(dir)
if isnil(ent) {
break
}
2019-09-15 18:07:40 +02:00
name := tos_clone(byteptr(ent.d_name))
2019-08-16 14:05:11 +02:00
if name != '.' && name != '..' && name != '' {
res << name
}
}
C.closedir(dir)
return res
}
2019-08-17 15:17:43 +02:00
/*
pub fn is_dir(path string) bool {
//$if linux {
//C.syscall(4, path.str) // sys_newstat
//}
2019-08-17 15:17:43 +02:00
dir := C.opendir(path.str)
res := !isnil(dir)
if res {
C.closedir(dir)
}
return res
}
*/
/*
2020-05-17 13:51:18 +02:00
pub fn (mut f File) fseek(pos, mode int) {
}
*/
2019-08-17 15:17:43 +02:00
// mkdir creates a new directory with the specified path.
2019-11-23 17:55:18 +01:00
pub fn mkdir(path string) ?bool {
2019-12-19 22:29:37 +01:00
if path == '.' {
return true
}
/*
mut k := 0
defer {
k = 1
}
*/
2020-07-21 15:28:30 +02:00
apath := real_path(path)
//defer {
//apath.free()
//}
2020-07-21 15:28:30 +02:00
/*
$if linux {
2020-01-05 20:13:35 +01:00
$if !android {
ret := C.syscall(sys_mkdir, apath.str, 511)
if ret == -1 {
2020-01-21 16:58:47 +01:00
return error(posix_get_error_msg(C.errno))
2020-01-05 20:13:35 +01:00
}
return true
2019-12-31 08:53:53 +01:00
}
}
2020-07-21 15:28:30 +02:00
*/
r := unsafe {
C.mkdir(charptr(apath.str), 511)
}
2019-11-23 17:55:18 +01:00
if r == -1 {
2020-01-21 16:58:47 +01:00
return error(posix_get_error_msg(C.errno))
2019-11-23 17:55:18 +01:00
}
return true
2019-08-17 15:17:43 +02:00
}
2019-11-07 14:01:17 +01:00
// exec starts the specified command, waits for it to complete, and returns its output.
pub fn exec(cmd string) ?Result {
2019-12-19 22:29:37 +01:00
// if cmd.contains(';') || cmd.contains('&&') || cmd.contains('||') || cmd.contains('\n') {
// return error(';, &&, || and \\n are not allowed in shell commands')
// }
2019-11-07 14:01:17 +01:00
pcmd := '$cmd 2>&1'
f := vpopen(pcmd)
if isnil(f) {
return error('exec("$cmd") failed')
}
buf := [4096]byte{}
2020-02-03 04:01:39 +01:00
mut res := strings.new_builder(1024)
for C.fgets(charptr(buf), 4096, f) != 0 {
2020-05-18 21:38:06 +02:00
bufbp := byteptr(buf)
2020-07-21 15:28:30 +02:00
res.write_bytes(bufbp, vstrlen(bufbp))
2019-11-07 14:01:17 +01:00
}
soutput := res.str()
2020-07-21 15:28:30 +02:00
// res.free()
2019-11-07 14:01:17 +01:00
exit_code := vpclose(f)
if exit_code == 127 {
return error_with_code(soutput, 127)
}
2019-12-19 22:29:37 +01:00
return Result{
exit_code: exit_code
2020-05-18 21:38:06 +02:00
output: soutput
2019-11-07 14:01:17 +01:00
}
}
2019-12-19 22:29:37 +01:00
pub struct Command {
mut:
f voidptr
pub mut:
eof bool
pub:
path string
redirect_stdout bool
}
//pub fn command(cmd Command) Command {
//}
pub fn (mut c Command) start()? {
pcmd := '$c.path 2>&1'
c.f = vpopen(pcmd)
if isnil(c.f) {
return error('exec("$c.path") failed')
}
}
pub fn (mut c Command) read_line() string {
buf := [4096]byte{}
mut res := strings.new_builder(1024)
unsafe {
for C.fgets(charptr(buf), 4096, c.f) != 0 {
bufbp := byteptr(buf)
len := vstrlen(bufbp)
for i in 0..len {
if int(bufbp[i]) == `\n` {
res.write_bytes(bufbp, i)
return res.str()
}
}
res.write_bytes(bufbp, len)
}
}
c.eof = true
return res.str()
}
pub fn (c &Command) close()? {
exit_code := vpclose(c.f)
if exit_code == 127 {
return error_with_code('error', 127)
}
}
pub fn symlink(origin string, target string) ?bool {
2020-07-14 00:16:31 +02:00
res := C.symlink(charptr(origin.str), charptr(target.str))
2020-01-05 20:13:35 +01:00
if res == 0 {
return true
}
2020-01-21 16:58:47 +01:00
return error(posix_get_error_msg(C.errno))
}
// get_error_msg return error code representation in string.
pub fn get_error_msg(code int) string {
return posix_get_error_msg(code)
2019-12-27 19:10:06 +01:00
}
2020-05-17 13:51:18 +02:00
pub fn (mut f File) close() {
2020-08-01 23:07:37 +02:00
if !f.is_opened {
return
}
2020-08-01 23:07:37 +02:00
f.is_opened = false
2020-07-21 15:28:30 +02:00
/*
$if linux {
2020-01-05 20:13:35 +01:00
$if !android {
C.syscall(sys_close, f.fd)
return
}
}
2020-07-21 15:28:30 +02:00
*/
C.fflush(f.cfile)
C.fclose(f.cfile)
}
2020-05-31 12:57:26 +02:00
pub fn debugger_present() bool {
return false
}
fn C.mkstemp(stemplate byteptr) int
// `is_writable_folder` - `folder` exists and is writable to the process
pub fn is_writable_folder(folder string) ?bool {
if !os.exists(folder) {
return error('`$folder` does not exist')
}
if !os.is_dir(folder) {
return error('`folder` is not a folder')
}
tmp_perm_check := os.join_path(folder, 'XXXXXX')
unsafe {
2020-11-06 15:26:59 +01:00
x := C.mkstemp(charptr(tmp_perm_check.str))
if -1 == x {
return error('folder `$folder` is not writable')
}
C.close(x)
}
os.rm(tmp_perm_check)
return true
}
[inline]
pub fn getpid() int {
return C.getpid()
}