35
35
#include <unistd.h>
36
36
#include <sys/types.h>
37
37
#include <sys/stat.h>
38
- #include <sys/file.h>
39
38
#include <fcntl.h>
40
39
#include <sys/socket.h>
41
40
#include <sys/un.h>
65
64
extern char * * environ ;
66
65
# endif
67
66
68
-
69
67
static uv_err_t last_err ;
70
68
71
69
struct uv_ares_data_s {
@@ -80,33 +78,6 @@ struct uv_ares_data_s {
80
78
81
79
static struct uv_ares_data_s ares_data ;
82
80
83
- typedef struct {
84
- const char * lockfile ;
85
- int lockfd ;
86
- } uv_flock_t ;
87
-
88
-
89
- /* Create a new advisory file lock for `filename`.
90
- * Call `uv_flock_acquire()` to actually acquire the lock.
91
- */
92
- int uv_flock_init (uv_flock_t * lock , const char * filename );
93
-
94
- /* Try to acquire the file lock. Returns 0 on success, -1 on error.
95
- * Does not wait for the lock to be released if it is held by another process.
96
- *
97
- * If `locked` is not NULL, the memory pointed it points to is set to 1 if
98
- * the file is locked by another process. Only relevant in error scenarios.
99
- */
100
- int uv_flock_acquire (uv_flock_t * lock , int * locked );
101
-
102
- /* Release the file lock. Returns 0 on success, -1 on error.
103
- */
104
- int uv_flock_release (uv_flock_t * lock );
105
-
106
- /* Destroy the file lock. Releases the file lock and associated resources.
107
- */
108
- int uv_flock_destroy (uv_flock_t * lock );
109
-
110
81
void uv__req_init (uv_req_t * );
111
82
void uv__next (EV_P_ ev_idle * watcher , int revents );
112
83
static int uv__stream_open (uv_stream_t * , int fd , int flags );
@@ -1838,7 +1809,6 @@ int uv_pipe_init(uv_pipe_t* handle) {
1838
1809
uv_counters ()-> pipe_init ++ ;
1839
1810
1840
1811
handle -> type = UV_NAMED_PIPE ;
1841
- handle -> pipe_flock = NULL ; /* Only set by listener. */
1842
1812
handle -> pipe_fname = NULL ; /* Only set by listener. */
1843
1813
1844
1814
ev_init (& handle -> write_watcher , uv__stream_io );
@@ -1858,7 +1828,6 @@ int uv_pipe_init(uv_pipe_t* handle) {
1858
1828
int uv_pipe_bind (uv_pipe_t * handle , const char * name ) {
1859
1829
struct sockaddr_un sun ;
1860
1830
const char * pipe_fname ;
1861
- uv_flock_t * pipe_flock ;
1862
1831
int saved_errno ;
1863
1832
int locked ;
1864
1833
int sockfd ;
@@ -1867,7 +1836,6 @@ int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
1867
1836
1868
1837
saved_errno = errno ;
1869
1838
pipe_fname = NULL ;
1870
- pipe_flock = NULL ;
1871
1839
sockfd = -1 ;
1872
1840
status = -1 ;
1873
1841
bound = 0 ;
@@ -1887,20 +1855,6 @@ int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
1887
1855
/* We've got a copy, don't touch the original any more. */
1888
1856
name = NULL ;
1889
1857
1890
- /* Create and acquire a file lock for this UNIX socket. */
1891
- if ((pipe_flock = malloc (sizeof * pipe_flock )) == NULL
1892
- || uv_flock_init (pipe_flock , pipe_fname ) == -1 ) {
1893
- uv_err_new ((uv_handle_t * )handle , ENOMEM );
1894
- goto out ;
1895
- }
1896
-
1897
- if (uv_flock_acquire (pipe_flock , & locked ) == -1 ) {
1898
- /* Another process holds the lock so the socket is in use. */
1899
- uv_err_new_artificial ((uv_handle_t * )handle ,
1900
- locked ? UV_EADDRINUSE : UV_EACCESS );
1901
- goto out ;
1902
- }
1903
-
1904
1858
if ((sockfd = uv__socket (AF_UNIX , SOCK_STREAM , 0 )) == -1 ) {
1905
1859
uv_err_new ((uv_handle_t * )handle , errno );
1906
1860
goto out ;
@@ -1931,7 +1885,6 @@ int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
1931
1885
1932
1886
/* Success. */
1933
1887
handle -> pipe_fname = pipe_fname ; /* Is a strdup'ed copy. */
1934
- handle -> pipe_flock = pipe_flock ;
1935
1888
handle -> fd = sockfd ;
1936
1889
status = 0 ;
1937
1890
@@ -1945,10 +1898,6 @@ int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
1945
1898
}
1946
1899
uv__close (sockfd );
1947
1900
1948
- if (pipe_flock ) {
1949
- uv_flock_destroy (pipe_flock );
1950
- }
1951
-
1952
1901
free ((void * )pipe_fname );
1953
1902
}
1954
1903
@@ -2005,11 +1954,6 @@ static int uv_pipe_cleanup(uv_pipe_t* handle) {
2005
1954
free ((void * )handle -> pipe_fname );
2006
1955
}
2007
1956
2008
- if (handle -> pipe_flock ) {
2009
- uv_flock_destroy ((uv_flock_t * )handle -> pipe_flock );
2010
- free (handle -> pipe_flock );
2011
- }
2012
-
2013
1957
errno = saved_errno ;
2014
1958
return status ;
2015
1959
}
@@ -2236,6 +2180,7 @@ size_t uv__strlcpy(char* dst, const char* src, size_t size) {
2236
2180
2237
2181
uv_stream_t * uv_std_handle (uv_std_type type ) {
2238
2182
assert (0 && "implement me" );
2183
+ return NULL ;
2239
2184
}
2240
2185
2241
2186
@@ -2410,125 +2355,3 @@ int uv_process_kill(uv_process_t* process, int signum) {
2410
2355
return 0 ;
2411
2356
}
2412
2357
}
2413
-
2414
-
2415
- #define LOCKFILE_SUFFIX ".lock"
2416
- int uv_flock_init (uv_flock_t * lock , const char * filename ) {
2417
- int saved_errno ;
2418
- int status ;
2419
- char * lockfile ;
2420
-
2421
- saved_errno = errno ;
2422
- status = -1 ;
2423
-
2424
- lock -> lockfd = -1 ;
2425
- lock -> lockfile = NULL ;
2426
-
2427
- if ((lockfile = malloc (strlen (filename ) + sizeof LOCKFILE_SUFFIX )) == NULL ) {
2428
- goto out ;
2429
- }
2430
-
2431
- strcpy (lockfile , filename );
2432
- strcat (lockfile , LOCKFILE_SUFFIX );
2433
- lock -> lockfile = lockfile ;
2434
- status = 0 ;
2435
-
2436
- out :
2437
- errno = saved_errno ;
2438
- return status ;
2439
- }
2440
- #undef LOCKFILE_SUFFIX
2441
-
2442
-
2443
- int uv_flock_acquire (uv_flock_t * lock , int * locked_p ) {
2444
- char buf [32 ];
2445
- int saved_errno ;
2446
- int status ;
2447
- int lockfd ;
2448
- int locked ;
2449
-
2450
- saved_errno = errno ;
2451
- status = -1 ;
2452
- lockfd = -1 ;
2453
- locked = 0 ;
2454
-
2455
- do {
2456
- lockfd = open (lock -> lockfile , O_WRONLY | O_CREAT , 0666 );
2457
- }
2458
- while (lockfd == -1 && errno == EINTR );
2459
-
2460
- if (lockfd == -1 ) {
2461
- goto out ;
2462
- }
2463
-
2464
- do {
2465
- status = flock (lockfd , LOCK_EX | LOCK_NB );
2466
- }
2467
- while (status == -1 && errno == EINTR );
2468
-
2469
- if (status == -1 ) {
2470
- locked = (errno == EAGAIN ); /* Lock is held by another process. */
2471
- goto out ;
2472
- }
2473
-
2474
- snprintf (buf , sizeof buf , "%d\n" , getpid ());
2475
- do {
2476
- status = write (lockfd , buf , strlen (buf ));
2477
- }
2478
- while (status == -1 && errno == EINTR );
2479
-
2480
- lock -> lockfd = lockfd ;
2481
- status = 0 ;
2482
-
2483
- out :
2484
- if (status ) {
2485
- uv__close (lockfd );
2486
- }
2487
-
2488
- if (locked_p ) {
2489
- * locked_p = locked ;
2490
- }
2491
-
2492
- errno = saved_errno ;
2493
- return status ;
2494
- }
2495
-
2496
-
2497
- int uv_flock_release (uv_flock_t * lock ) {
2498
- int saved_errno ;
2499
- int status ;
2500
-
2501
- saved_errno = errno ;
2502
- status = -1 ;
2503
-
2504
- if (unlink (lock -> lockfile ) == -1 ) {
2505
- /* Now what? */
2506
- goto out ;
2507
- }
2508
-
2509
- uv__close (lock -> lockfd );
2510
- lock -> lockfd = -1 ;
2511
- status = 0 ;
2512
-
2513
- out :
2514
- errno = saved_errno ;
2515
- return status ;
2516
- }
2517
-
2518
-
2519
- int uv_flock_destroy (uv_flock_t * lock ) {
2520
- int saved_errno ;
2521
- int status ;
2522
-
2523
- saved_errno = errno ;
2524
- status = unlink (lock -> lockfile );
2525
-
2526
- uv__close (lock -> lockfd );
2527
- lock -> lockfd = -1 ;
2528
-
2529
- free ((void * )lock -> lockfile );
2530
- lock -> lockfile = NULL ;
2531
-
2532
- errno = saved_errno ;
2533
- return status ;
2534
- }
0 commit comments