summaryrefslogtreecommitdiff
path: root/source3/smbd/oplock.c
blob: 7033eddc163855111433db872f83254dfaf69f13 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
/* 
   Unix SMB/Netbios implementation.
   Version 1.9.
   oplock processing
   Copyright (C) Andrew Tridgell 1992-1998
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "includes.h"

extern int DEBUGLEVEL;

/* Oplock ipc UDP socket. */
static int oplock_sock = -1;
uint16 global_oplock_port = 0;

/* Current number of oplocks we have outstanding. */
static int32 exclusive_oplocks_open = 0;
static int32 level_II_oplocks_open = 0;
BOOL global_client_failed_oplock_break = False;
BOOL global_oplock_break = False;

extern int smb_read_error;

static struct kernel_oplocks *koplocks;

static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval, BOOL local);

/****************************************************************************
 Get the number of current exclusive oplocks.
****************************************************************************/

int32 get_number_of_exclusive_open_oplocks(void)
{
  return exclusive_oplocks_open;
}

/****************************************************************************
 Return True if an oplock message is pending.
****************************************************************************/

BOOL oplock_message_waiting(fd_set *fds)
{
	if (koplocks && koplocks->msg_waiting(fds))
		return True;

	if (FD_ISSET(oplock_sock, fds))
		return True;

	return False;
}

/****************************************************************************
 Read an oplock break message from either the oplock UDP fd or the
 kernel (if kernel oplocks are supported).

 If timeout is zero then *fds contains the file descriptors that
 are ready to be read and acted upon. If timeout is non-zero then
 *fds contains the file descriptors to be selected on for read.
 The timeout is in milliseconds

****************************************************************************/

BOOL receive_local_message(fd_set *fds, char *buffer, int buffer_len, int timeout)
{
  struct sockaddr_in from;
  int fromlen = sizeof(from);
  int32 msg_len = 0;

  smb_read_error = 0;

  if(timeout != 0) {
	  struct timeval to;
	  int selrtn;
	  int maxfd = oplock_sock;

	  if (koplocks && koplocks->notification_fd != -1) {
		  FD_SET(koplocks->notification_fd, fds);
		  maxfd = MAX(maxfd, koplocks->notification_fd);
	  }

	  to.tv_sec = timeout / 1000;
	  to.tv_usec = (timeout % 1000) * 1000;

	  selrtn = sys_select(maxfd+1,fds,&to);

	  if (selrtn == -1 && errno == EINTR) {
		  /* could be a kernel oplock interrupt */
		  if (koplocks && koplocks->msg_waiting(fds)) {
			  return koplocks->receive_message(fds, buffer, buffer_len);
		  }
	  }

	  /* Check if error */
	  if(selrtn == -1) {
		  /* something is wrong. Maybe the socket is dead? */
		  smb_read_error = READ_ERROR;
		  return False;
	  }

	  /* Did we timeout ? */
	  if (selrtn == 0) {
		  smb_read_error = READ_TIMEOUT;
		  return False;
	  }
  }

  if (koplocks && koplocks->msg_waiting(fds)) {
	  return koplocks->receive_message(fds, buffer, buffer_len);
  }

  if (!FD_ISSET(oplock_sock, fds)) return False;

  /*
   * From here down we deal with the smbd <--> smbd
   * oplock break protocol only.
   */

  /*
   * Read a loopback udp message.
   */
  msg_len = recvfrom(oplock_sock, &buffer[OPBRK_CMD_HEADER_LEN],
                     buffer_len - OPBRK_CMD_HEADER_LEN, 0,
                     (struct sockaddr *)&from, &fromlen);

  if(msg_len < 0) {
    DEBUG(0,("receive_local_message. Error in recvfrom. (%s).\n",strerror(errno)));
    return False;
  }

  /* Validate message length. */
  if(msg_len > (buffer_len - OPBRK_CMD_HEADER_LEN)) {
    DEBUG(0,("receive_local_message: invalid msg_len (%d) max can be %d\n",
              msg_len,
              buffer_len  - OPBRK_CMD_HEADER_LEN));
    return False;
  }

  /* Validate message from address (must be localhost). */
  if(from.sin_addr.s_addr != htonl(INADDR_LOOPBACK)) {
    DEBUG(0,("receive_local_message: invalid 'from' address \
(was %lx should be 127.0.0.1\n", (long)from.sin_addr.s_addr));
   return False;
  }

  /* Setup the message header */
  SIVAL(buffer,OPBRK_CMD_LEN_OFFSET,msg_len);
  SSVAL(buffer,OPBRK_CMD_PORT_OFFSET,ntohs(from.sin_port));

  return True;
}

/****************************************************************************
 Attempt to set an oplock on a file. Always succeeds if kernel oplocks are
 disabled (just sets flags). Returns True if oplock set.
****************************************************************************/
BOOL set_file_oplock(files_struct *fsp, int oplock_type)
{
	if (koplocks && !koplocks->set_oplock(fsp, oplock_type))
		return False;

	fsp->oplock_type = oplock_type;
	fsp->sent_oplock_break = NO_BREAK_SENT;
	if (oplock_type == LEVEL_II_OPLOCK)
		level_II_oplocks_open++;
	else
		exclusive_oplocks_open++;

	DEBUG(5,("set_file_oplock: granted oplock on file %s, dev = %x, inode = %.0f, tv_sec = %x, tv_usec = %x\n",
		 fsp->fsp_name, (unsigned int)fsp->dev, (double)fsp->inode,
		 (int)fsp->open_time.tv_sec, (int)fsp->open_time.tv_usec ));

	return True;
}

/****************************************************************************
 Attempt to release an oplock on a file. Decrements oplock count.
****************************************************************************/

void release_file_oplock(files_struct *fsp)
{
	if (koplocks) koplocks->release_oplock(fsp);

	if (fsp->oplock_type == LEVEL_II_OPLOCK)
		level_II_oplocks_open--;
	else
		exclusive_oplocks_open--;
	
	fsp->oplock_type = NO_OPLOCK;
	fsp->sent_oplock_break = NO_BREAK_SENT;
	
	flush_write_cache(fsp, OPLOCK_RELEASE_FLUSH);
}

/****************************************************************************
 Attempt to downgrade an oplock on a file. Doesn't decrement oplock count.
****************************************************************************/

static void downgrade_file_oplock(files_struct *fsp)
{
	if (koplocks) koplocks->release_oplock(fsp);
	fsp->oplock_type = LEVEL_II_OPLOCK;
	exclusive_oplocks_open--;
	level_II_oplocks_open++;
	fsp->sent_oplock_break = NO_BREAK_SENT;
}

/****************************************************************************
 Remove a file oplock. Copes with level II and exclusive.
 Locks then unlocks the share mode lock. Client can decide to go directly
 to none even if a "break-to-level II" was sent.
****************************************************************************/

BOOL remove_oplock(files_struct *fsp, BOOL break_to_none)
{
	SMB_DEV_T dev = fsp->dev;
	SMB_INO_T inode = fsp->inode;
	BOOL ret = True;

	/* Remove the oplock flag from the sharemode. */
	if (lock_share_entry_fsp(fsp) == False) {
		DEBUG(0,("remove_oplock: failed to lock share entry for file %s\n",
			 fsp->fsp_name ));
		ret = False;
	}

	if (fsp->sent_oplock_break == EXCLUSIVE_BREAK_SENT || break_to_none) {
		/*
		 * Deal with a reply when a break-to-none was sent.
		 */

		if(remove_share_oplock(fsp)==False) {
			DEBUG(0,("remove_oplock: failed to remove share oplock for file %s fnum %d, \
dev = %x, inode = %.0f\n", fsp->fsp_name, fsp->fnum, (unsigned int)dev, (double)inode));
			ret = False;
		}

		release_file_oplock(fsp);
	} else {
		/*
		 * Deal with a reply when a break-to-level II was sent.
		 */
		if(downgrade_share_oplock(fsp)==False) {
			DEBUG(0,("remove_oplock: failed to downgrade share oplock for file %s fnum %d, \
dev = %x, inode = %.0f\n", fsp->fsp_name, fsp->fnum, (unsigned int)dev, (double)inode));
			ret = False;
		}
		
		downgrade_file_oplock(fsp);
	}

	unlock_share_entry_fsp(fsp);
	return ret;
}

/****************************************************************************
 Setup the listening set of file descriptors for an oplock break
 message either from the UDP socket or from the kernel. Returns the maximum
 fd used.
****************************************************************************/

int setup_oplock_select_set( fd_set *fds)
{
	int maxfd = oplock_sock;

	if(oplock_sock == -1)
		return 0;

	FD_SET(oplock_sock,fds);

	if (koplocks && koplocks->notification_fd != -1) {
		FD_SET(koplocks->notification_fd, fds);
		maxfd = MAX(maxfd, koplocks->notification_fd);
	}

	return maxfd;
}

/****************************************************************************
 Process an oplock break message - whether it came from the UDP socket
 or from the kernel.
****************************************************************************/
BOOL process_local_message(char *buffer, int buf_size)
{
  int32 msg_len;
  uint16 from_port;
  char *msg_start;
  SMB_DEV_T dev;
  SMB_INO_T inode;
  pid_t remotepid;
  struct timeval tval;
  struct timeval *ptval = NULL;
  uint16 break_cmd_type;

  msg_len = IVAL(buffer,OPBRK_CMD_LEN_OFFSET);
  from_port = SVAL(buffer,OPBRK_CMD_PORT_OFFSET);

  msg_start = &buffer[OPBRK_CMD_HEADER_LEN];

  DEBUG(5,("process_local_message: Got a message of length %d from port (%d)\n", 
            msg_len, from_port));

  /* 
   * Pull the info out of the requesting packet.
   */

  break_cmd_type = SVAL(msg_start,OPBRK_MESSAGE_CMD_OFFSET);

  switch(break_cmd_type)
  {
    case KERNEL_OPLOCK_BREAK_CMD:
	    if (!koplocks) {
		    DEBUG(0,("unexpected kernel oplock break!\n"));
		    break;
	    } 
	    if (!koplocks->parse_message(msg_start, msg_len, &inode, &dev)) {
		    DEBUG(0,("kernel oplock break parse failure!\n"));
	    }
	    break;

    case OPLOCK_BREAK_CMD:
    case LEVEL_II_OPLOCK_BREAK_CMD:

      /* Ensure that the msg length is correct. */
      if(msg_len != OPLOCK_BREAK_MSG_LEN)
      {
        DEBUG(0,("process_local_message: incorrect length for OPLOCK_BREAK_CMD (was %d, should be %d).\n",
              (int)msg_len, (int)OPLOCK_BREAK_MSG_LEN));
        return False;
      }
      {
        long usec;
        time_t sec;

        memcpy((char *)&inode, msg_start+OPLOCK_BREAK_INODE_OFFSET,sizeof(inode));
        memcpy((char *)&dev, msg_start+OPLOCK_BREAK_DEV_OFFSET,sizeof(dev));
        memcpy((char *)&sec, msg_start+OPLOCK_BREAK_SEC_OFFSET,sizeof(sec));
        tval.tv_sec = sec;
        memcpy((char *)&usec, msg_start+OPLOCK_BREAK_USEC_OFFSET, sizeof(usec));
        tval.tv_usec = usec;

        ptval = &tval;

        memcpy((char *)&remotepid, msg_start+OPLOCK_BREAK_PID_OFFSET,sizeof(remotepid));

        DEBUG(5,("process_local_message: (%s) oplock break request from \
pid %d, port %d, dev = %x, inode = %.0f\n",
             (break_cmd_type == OPLOCK_BREAK_CMD) ? "exclusive" : "level II",
             (int)remotepid, from_port, (unsigned int)dev, (double)inode));
      }
      break;

    /* 
     * Keep this as a debug case - eventually we can remove it.
     */
    case 0x8001:
      DEBUG(0,("process_local_message: Received unsolicited break \
reply - dumping info.\n"));

      if(msg_len != OPLOCK_BREAK_MSG_LEN)
      {
        DEBUG(0,("process_local_message: ubr: incorrect length for reply \
(was %d, should be %d).\n", (int)msg_len, (int)OPLOCK_BREAK_MSG_LEN));
        return False;
      }

      {
        memcpy((char *)&inode, msg_start+OPLOCK_BREAK_INODE_OFFSET,sizeof(inode));
        memcpy((char *)&remotepid, msg_start+OPLOCK_BREAK_PID_OFFSET,sizeof(remotepid));
        memcpy((char *)&dev, msg_start+OPLOCK_BREAK_DEV_OFFSET,sizeof(dev));

        DEBUG(0,("process_local_message: unsolicited oplock break reply from \
pid %d, port %d, dev = %x, inode = %.0f\n", (int)remotepid, from_port, (unsigned int)dev, (double)inode));

       }
       return False;

    default:
      DEBUG(0,("process_local_message: unknown UDP message command code (%x) - ignoring.\n",
                (unsigned int)SVAL(msg_start,0)));
      return False;
  }

  /*
   * Now actually process the break request.
   */

  if((exclusive_oplocks_open + level_II_oplocks_open) != 0)
  {
    if (oplock_break(dev, inode, ptval, False) == False)
    {
      DEBUG(0,("process_local_message: oplock break failed.\n"));
      return False;
    }
  }
  else
  {
    /*
     * If we have no record of any currently open oplocks,
     * it's not an error, as a close command may have
     * just been issued on the file that was oplocked.
     * Just log a message and return success in this case.
     */
    DEBUG(3,("process_local_message: oplock break requested with no outstanding \
oplocks. Returning success.\n"));
  }

  /* 
   * Do the appropriate reply - none in the kernel or level II case.
   */

  if(SVAL(msg_start,OPBRK_MESSAGE_CMD_OFFSET) == OPLOCK_BREAK_CMD)
  {
    struct sockaddr_in toaddr;

    /* Send the message back after OR'ing in the 'REPLY' bit. */
    SSVAL(msg_start,OPBRK_MESSAGE_CMD_OFFSET,OPLOCK_BREAK_CMD | CMD_REPLY);

    memset((char *)&toaddr,'\0',sizeof(toaddr));
    toaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    toaddr.sin_port = htons(from_port);
    toaddr.sin_family = AF_INET;

    if(sendto( oplock_sock, msg_start, OPLOCK_BREAK_MSG_LEN, 0,
            (struct sockaddr *)&toaddr, sizeof(toaddr)) < 0) 
    {
      DEBUG(0,("process_local_message: sendto process %d failed. Errno was %s\n",
                (int)remotepid, strerror(errno)));
      return False;
    }

    DEBUG(5,("process_local_message: oplock break reply sent to \
pid %d, port %d, for file dev = %x, inode = %.0f\n",
          (int)remotepid, from_port, (unsigned int)dev, (double)inode));
  }

  return True;
}

/****************************************************************************
 Set up an oplock break message.
****************************************************************************/

static void prepare_break_message(char *outbuf, files_struct *fsp, BOOL level2)
{
	memset(outbuf,'\0',smb_size);
	set_message(outbuf,8,0,True);

	SCVAL(outbuf,smb_com,SMBlockingX);
	SSVAL(outbuf,smb_tid,fsp->conn->cnum);
	SSVAL(outbuf,smb_pid,0xFFFF);
	SSVAL(outbuf,smb_uid,0);
	SSVAL(outbuf,smb_mid,0xFFFF);
	SCVAL(outbuf,smb_vwv0,0xFF);
	SSVAL(outbuf,smb_vwv2,fsp->fnum);
	SCVAL(outbuf,smb_vwv3,LOCKING_ANDX_OPLOCK_RELEASE);
	SCVAL(outbuf,smb_vwv3+1,level2 ? OPLOCKLEVEL_II : OPLOCKLEVEL_NONE);
}

/****************************************************************************
 Function to do the waiting before sending a local break.
****************************************************************************/

static void wait_before_sending_break(BOOL local_request)
{
  extern struct timeval smb_last_time;

  if(local_request) {
    struct timeval cur_tv;
    long wait_left = (long)lp_oplock_break_wait_time();

	if (wait_left == 0)
		return;

    GetTimeOfDay(&cur_tv);

    wait_left -= ((cur_tv.tv_sec - smb_last_time.tv_sec)*1000) +
                ((cur_tv.tv_usec - smb_last_time.tv_usec)/1000);

    if(wait_left > 0) {
      wait_left = MIN(wait_left, 1000);
      sys_usleep(wait_left * 1000);
    }
  }
}

/****************************************************************************
 Ensure that we have a valid oplock.
****************************************************************************/
static files_struct *initial_break_processing(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval)
{
  files_struct *fsp = NULL;

  if( DEBUGLVL( 3 ) )
  {
    dbgtext( "initial_break_processing: called for dev = %x, inode = %.0f tv_sec = %x, tv_usec = %x.\n",
      (unsigned int)dev, (double)inode, tval ? (int)tval->tv_sec : 0,
      tval ? (int)tval->tv_usec : 0);
    dbgtext( "Current oplocks_open (exclusive = %d, levelII = %d)\n",
              exclusive_oplocks_open, level_II_oplocks_open );
  }

  /* We need to search the file open table for the
     entry containing this dev and inode, and ensure
     we have an oplock on it. */
  fsp = file_find_dit(dev, inode, tval);

  if(fsp == NULL)
  {
    /* The file could have been closed in the meantime - return success. */
    if( DEBUGLVL( 3 ) )
    {
      dbgtext( "initial_break_processing: cannot find open file with " );
      dbgtext( "dev = %x, inode = %.0f ", (unsigned int)dev, (double)inode);
      dbgtext( "allowing break to succeed.\n" );
    }
    return NULL;
  }

  /* Ensure we have an oplock on the file */

  /* There is a potential race condition in that an oplock could
     have been broken due to another udp request, and yet there are
     still oplock break messages being sent in the udp message
     queue for this file. So return true if we don't have an oplock,
     as we may have just freed it.
   */

  if(fsp->oplock_type == NO_OPLOCK)
  {
    if( DEBUGLVL( 3 ) )
    {
      dbgtext( "initial_break_processing: file %s ", fsp->fsp_name );
      dbgtext( "(dev = %x, inode = %.0f) has no oplock.\n", (unsigned int)dev, (double)inode );
      dbgtext( "Allowing break to succeed regardless.\n" );
    }
    return NULL;
  }

  return fsp;
}

/****************************************************************************
 Process a level II oplock break directly.
****************************************************************************/

BOOL oplock_break_level2(files_struct *fsp, BOOL local_request, int token)
{
  extern uint32 global_client_caps;
  char outbuf[128];
  BOOL got_lock = False;
  SMB_DEV_T dev = fsp->dev;
  SMB_INO_T inode = fsp->inode;

  /*
   * We can have a level II oplock even if the client is not
   * level II oplock aware. In this case just remove the
   * flags and don't send the break-to-none message to
   * the client.
   */

  if (global_client_caps & CAP_LEVEL_II_OPLOCKS) {
    /*
     * If we are sending an oplock break due to an SMB sent
     * by our own client we ensure that we wait at leat
     * lp_oplock_break_wait_time() milliseconds before sending
     * the packet. Sending the packet sooner can break Win9x
     * and has reported to cause problems on NT. JRA.
     */

    wait_before_sending_break(local_request);

    /* Prepare the SMBlockingX message. */

    prepare_break_message( outbuf, fsp, False);
    if (!send_smb(smbd_server_fd(), outbuf))
		exit_server("oplock_break_level2: send_smb failed.\n");
  }

  /*
   * Now we must update the shared memory structure to tell
   * everyone else we no longer have a level II oplock on 
   * this open file. If local_request is true then token is
   * the existing lock on the shared memory area.
   */

  if(!local_request && lock_share_entry_fsp(fsp) == False) {
      DEBUG(0,("oplock_break_level2: unable to lock share entry for file %s\n", fsp->fsp_name ));
  } else {
    got_lock = True;
  }

  if(remove_share_oplock(fsp)==False) {
    DEBUG(0,("oplock_break_level2: unable to remove level II oplock for file %s\n", fsp->fsp_name ));
  }

  if (!local_request && got_lock)
    unlock_share_entry_fsp(fsp);

  fsp->oplock_type = NO_OPLOCK;
  level_II_oplocks_open--;

  if(level_II_oplocks_open < 0)
  {
    DEBUG(0,("oplock_break_level2: level_II_oplocks_open < 0 (%d). PANIC ERROR\n",
              level_II_oplocks_open));
    abort();
  }

  if( DEBUGLVL( 3 ) )
  {
    dbgtext( "oplock_break_level2: returning success for " );
    dbgtext( "dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode );
    dbgtext( "Current level II oplocks_open = %d\n", level_II_oplocks_open );
  }

  return True;
}

/****************************************************************************
 Process an oplock break directly.
****************************************************************************/

static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval, BOOL local_request)
{
  extern uint32 global_client_caps;
  extern struct current_user current_user;
  char *inbuf = NULL;
  char *outbuf = NULL;
  files_struct *fsp = NULL;
  time_t start_time;
  BOOL shutdown_server = False;
  BOOL oplock_timeout = False;
  connection_struct *saved_user_conn;
  connection_struct *saved_fsp_conn;
  int saved_vuid;
  pstring saved_dir; 
  int timeout = (OPLOCK_BREAK_TIMEOUT * 1000);
  pstring file_name;
  BOOL using_levelII;

  if((fsp = initial_break_processing(dev, inode, tval)) == NULL)
    return True;

  /*
   * Deal with a level II oplock going break to none separately.
   */

  if (LEVEL_II_OPLOCK_TYPE(fsp->oplock_type))
    return oplock_break_level2(fsp, local_request, -1);

  /* Mark the oplock break as sent - we don't want to send twice! */
  if (fsp->sent_oplock_break)
  {
    if( DEBUGLVL( 0 ) )
    {
      dbgtext( "oplock_break: ERROR: oplock_break already sent for " );
      dbgtext( "file %s ", fsp->fsp_name);
      dbgtext( "(dev = %x, inode = %.0f)\n", (unsigned int)dev, (double)inode );
    }

    /* We have to fail the open here as we cannot send another oplock break on
       this file whilst we are awaiting a response from the client - neither
       can we allow another open to succeed while we are waiting for the
       client.
     */
    return False;
  }

  if(global_oplock_break) {
    DEBUG(0,("ABORT : ABORT : recursion in oplock_break !!!!!\n"));
    abort();
  }

  /* Now comes the horrid part. We must send an oplock break to the client,
     and then process incoming messages until we get a close or oplock release.
     At this point we know we need a new inbuf/outbuf buffer pair.
     We cannot use these staticaly as we may recurse into here due to
     messages crossing on the wire.
   */

  if((inbuf = (char *)malloc(BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN))==NULL)
  {
    DEBUG(0,("oplock_break: malloc fail for input buffer.\n"));
    return False;
  }

  if((outbuf = (char *)malloc(BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN))==NULL)
  {
    DEBUG(0,("oplock_break: malloc fail for output buffer.\n"));
    free(inbuf);
    inbuf = NULL;
    return False;
  }

  /*
   * If we are sending an oplock break due to an SMB sent
   * by our own client we ensure that we wait at leat
   * lp_oplock_break_wait_time() milliseconds before sending
   * the packet. Sending the packet sooner can break Win9x
   * and has reported to cause problems on NT. JRA.
   */

  wait_before_sending_break(local_request);

  /* Prepare the SMBlockingX message. */

  if ((global_client_caps & CAP_LEVEL_II_OPLOCKS) && 
      !koplocks && /* NOTE: we force levelII off for kernel oplocks -
                      this will change when it is supported */
      lp_level2_oplocks(SNUM(fsp->conn))) {
	  using_levelII = True;
  } else {
	  using_levelII = False;
  }

  prepare_break_message( outbuf, fsp, using_levelII);
  /* Remember if we just sent a break to level II on this file. */
  fsp->sent_oplock_break = using_levelII?
	  LEVEL_II_BREAK_SENT:EXCLUSIVE_BREAK_SENT;

  if (!send_smb(smbd_server_fd(), outbuf))
    exit_server("oplock_break: send_smb failed.\n");

  /* We need this in case a readraw crosses on the wire. */
  global_oplock_break = True;
 
  /* Process incoming messages. */

  /* JRA - If we don't get a break from the client in OPLOCK_BREAK_TIMEOUT
     seconds we should just die.... */

  start_time = time(NULL);

  /*
   * Save the information we need to re-become the
   * user, then unbecome the user whilst we're doing this.
   */
  saved_user_conn = current_user.conn;
  saved_vuid = current_user.vuid;
  saved_fsp_conn = fsp->conn;
  vfs_GetWd(saved_fsp_conn,saved_dir);
  unbecome_user();
  /* Save the chain fnum. */
  file_chain_save();

  /*
   * From Charles Hoch <hoch@exemplary.com>. If the break processing
   * code closes the file (as it often does), then the fsp pointer here
   * points to free()'d memory. We *must* revalidate fsp each time
   * around the loop.
   */

  pstrcpy(file_name, fsp->fsp_name);

  while((fsp = initial_break_processing(dev, inode, tval)) &&
        OPEN_FSP(fsp) && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type))
  {
    if(receive_smb(smbd_server_fd(),inbuf, timeout) == False)
    {
      /*
       * Die if we got an error.
       */

      if (smb_read_error == READ_EOF) {
        DEBUG( 0, ( "oplock_break: end of file from client\n" ) );
        shutdown_server = True;
      } else if (smb_read_error == READ_ERROR) {
        DEBUG( 0, ("oplock_break: receive_smb error (%s)\n", strerror(errno)) );
        shutdown_server = True;
      } else if (smb_read_error == READ_TIMEOUT) {
        DEBUG( 0, ( "oplock_break: receive_smb timed out after %d seconds.\n",
                     OPLOCK_BREAK_TIMEOUT ) );
        oplock_timeout = True;
      }

      DEBUGADD( 0, ( "oplock_break failed for file %s ", file_name ) );
      DEBUGADD( 0, ( "(dev = %x, inode = %.0f).\n", (unsigned int)dev, (double)inode));

      break;
    }

    /*
     * There are certain SMB requests that we shouldn't allow
     * to recurse. opens, renames and deletes are the obvious
     * ones. This is handled in the switch_message() function.
     * If global_oplock_break is set they will push the packet onto
     * the pending smb queue and return -1 (no reply).
     * JRA.
     */

    process_smb(inbuf, outbuf);

    /*
     * Die if we go over the time limit.
     */

    if((time(NULL) - start_time) > OPLOCK_BREAK_TIMEOUT)
    {
      if( DEBUGLVL( 0 ) )
      {
        dbgtext( "oplock_break: no break received from client " );
        dbgtext( "within %d seconds.\n", OPLOCK_BREAK_TIMEOUT );
        dbgtext( "oplock_break failed for file %s ", fsp->fsp_name );
        dbgtext( "(dev = %x, inode = %.0f).\n", (unsigned int)dev, (double)inode );
      }
      oplock_timeout = True;
      break;
    }
  }

  /*
   * Go back to being the user who requested the oplock
   * break.
   */
  if((saved_user_conn != NULL) && (saved_vuid != UID_FIELD_INVALID) && !become_user(saved_user_conn, saved_vuid))
  {
    DEBUG( 0, ( "oplock_break: unable to re-become user!" ) );
    DEBUGADD( 0, ( "Shutting down server\n" ) );
    close(oplock_sock);
    exit_server("unable to re-become user");
  }
  /* Including the directory. */
  vfs_ChDir(saved_fsp_conn,saved_dir);

  /* Restore the chain fnum. */
  file_chain_restore();

  /* Free the buffers we've been using to recurse. */
  free(inbuf);
  free(outbuf);

  /* We need this in case a readraw crossed on the wire. */
  if(global_oplock_break)
    global_oplock_break = False;

  /*
   * If the client timed out then clear the oplock (or go to level II)
   * and continue. This seems to be what NT does and is better than dropping
   * the connection.
   */

  if(oplock_timeout && (fsp = initial_break_processing(dev, inode, tval)) &&
        OPEN_FSP(fsp) && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type))
  {
    DEBUG(0,("oplock_break: client failure in oplock break in file %s\n", fsp->fsp_name));
    remove_oplock(fsp,True);
    global_client_failed_oplock_break = True; /* Never grant this client an oplock again. */
  }

  /*
   * If the client had an error we must die.
   */

  if(shutdown_server)
  {
    DEBUG( 0, ( "oplock_break: client failure in break - " ) );
    DEBUGADD( 0, ( "shutting down this smbd.\n" ) );
    close(oplock_sock);
    exit_server("oplock break failure");
  }

  /* Santity check - remove this later. JRA */
  if(exclusive_oplocks_open < 0)
  {
    DEBUG(0,("oplock_break: exclusive_oplocks_open < 0 (%d). PANIC ERROR\n",
              exclusive_oplocks_open));
    abort();
  }

  if( DEBUGLVL( 3 ) )
  {
    dbgtext( "oplock_break: returning success for " );
    dbgtext( "dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode );
    dbgtext( "Current exclusive_oplocks_open = %d\n", exclusive_oplocks_open );
  }

  return True;
}

/****************************************************************************
Send an oplock break message to another smbd process. If the oplock is held 
by the local smbd then call the oplock break function directly.
****************************************************************************/

BOOL request_oplock_break(share_mode_entry *share_entry, 
                          SMB_DEV_T dev, SMB_INO_T inode)
{
  char op_break_msg[OPLOCK_BREAK_MSG_LEN];
  struct sockaddr_in addr_out;
  pid_t pid = sys_getpid();
  time_t start_time;
  int time_left;
  long usec;
  time_t sec;

  if(pid == share_entry->pid)
  {
    /* We are breaking our own oplock, make sure it's us. */
    if(share_entry->op_port != global_oplock_port)
    {
      DEBUG(0,("request_oplock_break: corrupt share mode entry - pid = %d, port = %d \
should be %d\n", (int)pid, share_entry->op_port, global_oplock_port));
      return False;
    }

    DEBUG(5,("request_oplock_break: breaking our own oplock\n"));

#if 1 /* JRA PARANOIA TEST.... */
    {
      files_struct *fsp = file_find_dit(dev, inode, &share_entry->time);
      if (!fsp) {
        DEBUG(0,("request_oplock_break: PANIC : breaking our own oplock requested for \
dev = %x, inode = %.0f, tv_sec = %x, tv_usec = %x and no fsp found !\n",
            (unsigned int)dev, (double)inode, (int)share_entry->time.tv_sec,
            (int)share_entry->time.tv_usec ));
        smb_panic("request_oplock_break: no fsp found for our own oplock\n");
      }
    }
#endif /* END JRA PARANOIA TEST... */

    /* Call oplock break direct. */
    return oplock_break(dev, inode, &share_entry->time, True);
  }

  /* We need to send a OPLOCK_BREAK_CMD message to the
     port in the share mode entry. */

  if (LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
    SSVAL(op_break_msg,OPBRK_MESSAGE_CMD_OFFSET,LEVEL_II_OPLOCK_BREAK_CMD);
  } else {
    SSVAL(op_break_msg,OPBRK_MESSAGE_CMD_OFFSET,OPLOCK_BREAK_CMD);
  }
  memcpy(op_break_msg+OPLOCK_BREAK_PID_OFFSET,(char *)&pid,sizeof(pid));
  sec = (time_t)share_entry->time.tv_sec;
  memcpy(op_break_msg+OPLOCK_BREAK_SEC_OFFSET,(char *)&sec,sizeof(sec));
  usec = (long)share_entry->time.tv_usec;
  memcpy(op_break_msg+OPLOCK_BREAK_USEC_OFFSET,(char *)&usec,sizeof(usec));
  memcpy(op_break_msg+OPLOCK_BREAK_DEV_OFFSET,(char *)&dev,sizeof(dev));
  memcpy(op_break_msg+OPLOCK_BREAK_INODE_OFFSET,(char *)&inode,sizeof(inode));

  /* set the address and port */
  memset((char *)&addr_out,'\0',sizeof(addr_out));
  addr_out.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
  addr_out.sin_port = htons( share_entry->op_port );
  addr_out.sin_family = AF_INET;
   
  if( DEBUGLVL( 3 ) )
  {
    dbgtext( "request_oplock_break: sending a oplock break message to " );
    dbgtext( "pid %d on port %d ", (int)share_entry->pid, share_entry->op_port );
    dbgtext( "for dev = %x, inode = %.0f, tv_sec = %x, tv_usec = %x\n",
            (unsigned int)dev, (double)inode, (int)share_entry->time.tv_sec,
            (int)share_entry->time.tv_usec );

  }

  if(sendto(oplock_sock,op_break_msg,OPLOCK_BREAK_MSG_LEN,0,
         (struct sockaddr *)&addr_out,sizeof(addr_out)) < 0)
  {
    if( DEBUGLVL( 0 ) )
    {
      dbgtext( "request_oplock_break: failed when sending a oplock " );
      dbgtext( "break message to pid %d ", (int)share_entry->pid );
      dbgtext( "on port %d ", share_entry->op_port );
      dbgtext( "for dev = %x, inode = %.0f, tv_sec = %x, tv_usec = %x\n",
          (unsigned int)dev, (double)inode, (int)share_entry->time.tv_sec,
          (int)share_entry->time.tv_usec );
      dbgtext( "Error was %s\n", strerror(errno) );
    }
    return False;
  }

  /*
   * If we just sent a message to a level II oplock share entry then
   * we are done and may return.
   */

  if (LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
    DEBUG(3,("request_oplock_break: sent break message to level II entry.\n"));
    return True;
  }

  /*
   * Now we must await the oplock broken message coming back
   * from the target smbd process. Timeout if it fails to
   * return in (OPLOCK_BREAK_TIMEOUT + OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR) seconds.
   * While we get messages that aren't ours, loop.
   */

  start_time = time(NULL);
  time_left = OPLOCK_BREAK_TIMEOUT+OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR;

  while(time_left >= 0)
  {
    char op_break_reply[OPBRK_CMD_HEADER_LEN+OPLOCK_BREAK_MSG_LEN];
    uint16 reply_from_port;
    char *reply_msg_start;
    fd_set fds;

    FD_ZERO(&fds);
    FD_SET(oplock_sock,&fds);

    if (koplocks && koplocks->notification_fd != -1) {
	    FD_SET(koplocks->notification_fd, &fds);
    }

    if(receive_local_message(&fds, op_break_reply, sizeof(op_break_reply),
               time_left ? time_left * 1000 : 1) == False)
    {
      if(smb_read_error == READ_TIMEOUT)
      {
        if( DEBUGLVL( 0 ) )
        {
          dbgtext( "request_oplock_break: no response received to oplock " );
          dbgtext( "break request to pid %d ", (int)share_entry->pid );
          dbgtext( "on port %d ", share_entry->op_port );
          dbgtext( "for dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode );
          dbgtext( "for dev = %x, inode = %.0f, tv_sec = %x, tv_usec = %x\n",
             (unsigned int)dev, (double)inode, (int)share_entry->time.tv_sec,
             (int)share_entry->time.tv_usec );
        }

        /*
         * This is a hack to make handling of failing clients more robust.
         * If a oplock break response message is not received in the timeout
         * period we may assume that the smbd servicing that client holding
         * the oplock has died and the client changes were lost anyway, so
         * we should continue to try and open the file.
         */
        break;
      }
      else
        if( DEBUGLVL( 0 ) )
        {
          dbgtext( "request_oplock_break: error in response received " );
          dbgtext( "to oplock break request to pid %d ", (int)share_entry->pid );
          dbgtext( "on port %d ", share_entry->op_port );
          dbgtext( "for dev = %x, inode = %.0f, tv_sec = %x, tv_usec = %x\n",
               (unsigned int)dev, (double)inode, (int)share_entry->time.tv_sec,
               (int)share_entry->time.tv_usec );
          dbgtext( "Error was (%s).\n", strerror(errno) );
        }
      return False;
    }

    reply_from_port = SVAL(op_break_reply,OPBRK_CMD_PORT_OFFSET);

    reply_msg_start = &op_break_reply[OPBRK_CMD_HEADER_LEN];


    /*
     * Test to see if this is the reply we are awaiting.
     */
    if((SVAL(reply_msg_start,OPBRK_MESSAGE_CMD_OFFSET) & CMD_REPLY) &&
       ((SVAL(reply_msg_start,OPBRK_MESSAGE_CMD_OFFSET) & ~CMD_REPLY) == OPLOCK_BREAK_CMD) &&
       (reply_from_port == share_entry->op_port) && 
       (memcmp(&reply_msg_start[OPLOCK_BREAK_PID_OFFSET], 
               &op_break_msg[OPLOCK_BREAK_PID_OFFSET],
               OPLOCK_BREAK_MSG_LEN - OPLOCK_BREAK_PID_OFFSET) == 0))
    {
      /*
       * This is the reply we've been waiting for.
       */
      break;
    }
    else
    {
      /*
       * This is another message - a break request.
       * Note that both kernel oplock break requests
       * and UDP inter-smbd oplock break requests will
       * be processed here.
       *
       * Process it to prevent potential deadlock.
       * Note that the code in switch_message() prevents
       * us from recursing into here as any SMB requests
       * we might process that would cause another oplock
       * break request to be made will be queued.
       * JRA.
       */

      process_local_message(op_break_reply, sizeof(op_break_reply));
    }

    time_left -= (time(NULL) - start_time);
  }

  DEBUG(3,("request_oplock_break: broke oplock.\n"));

  return True;
}

/****************************************************************************
  Attempt to break an oplock on a file (if oplocked).
  Returns True if the file was closed as a result of
  the oplock break, False otherwise.
  Used as a last ditch attempt to free a space in the 
  file table when we have run out.
****************************************************************************/
BOOL attempt_close_oplocked_file(files_struct *fsp)
{

  DEBUG(5,("attempt_close_oplocked_file: checking file %s.\n", fsp->fsp_name));

  if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && !fsp->sent_oplock_break && (fsp->fd != -1)) {
	  /* Try and break the oplock. */
	  if (oplock_break(fsp->dev, fsp->inode, &fsp->open_time, True)) {
		  if(file_find_fsp(fsp) == NULL) /* Did the oplock break close the file ? */
			  return True;
	  }
  }

  return False;
}

/****************************************************************************
 This function is called on any file modification or lock request. If a file
 is level 2 oplocked then it must tell all other level 2 holders to break to none.
****************************************************************************/

void release_level_2_oplocks_on_change(files_struct *fsp)
{
	share_mode_entry *share_list = NULL;
	pid_t pid = sys_getpid();
	int token = -1;
	int num_share_modes = 0;
	int i;

	/*
	 * If this file is level II oplocked then we need
	 * to grab the shared memory lock and inform all
	 * other files with a level II lock that they need
	 * to flush their read caches. We keep the lock over
	 * the shared memory area whilst doing this.
	 */

	if (!LEVEL_II_OPLOCK_TYPE(fsp->oplock_type))
		return;

	if (lock_share_entry_fsp(fsp) == False) {
		DEBUG(0,("release_level_2_oplocks_on_change: failed to lock share mode entry for file %s.\n", fsp->fsp_name ));
	}

	num_share_modes = get_share_modes(fsp->conn, fsp->dev, fsp->inode, &share_list);

	DEBUG(10,("release_level_2_oplocks_on_change: num_share_modes = %d\n", 
			num_share_modes ));

	for(i = 0; i < num_share_modes; i++) {
		share_mode_entry *share_entry = &share_list[i];

		/*
		 * As there could have been multiple writes waiting at the lock_share_entry
		 * gate we may not be the first to enter. Hence the state of the op_types
		 * in the share mode entries may be partly NO_OPLOCK and partly LEVEL_II
		 * oplock. It will do no harm to re-send break messages to those smbd's
		 * that are still waiting their turn to remove their LEVEL_II state, and
		 * also no harm to ignore existing NO_OPLOCK states. JRA.
		 */

		DEBUG(10,("release_level_2_oplocks_on_change: share_entry[%i]->op_type == %d\n",
				i, share_entry->op_type ));

		if (share_entry->op_type == NO_OPLOCK)
			continue;

		/* Paranoia .... */
		if (EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type)) {
			DEBUG(0,("release_level_2_oplocks_on_change: PANIC. share mode entry %d is an exlusive oplock !\n", i ));
			unlock_share_entry(fsp->conn, fsp->dev, fsp->inode);
			abort();
		}

		/*
		 * Check if this is a file we have open (including the
		 * file we've been called to do write_file on. If so
		 * then break it directly without releasing the lock.
		 */

		if (pid == share_entry->pid) {
			files_struct *new_fsp = file_find_dit(fsp->dev, fsp->inode, &share_entry->time);

			/* Paranoia check... */
			if(new_fsp == NULL) {
				DEBUG(0,("release_level_2_oplocks_on_change: PANIC. share mode entry %d is not a local file !\n", i ));
				unlock_share_entry(fsp->conn, fsp->dev, fsp->inode);
				abort();
			}

			DEBUG(10,("release_level_2_oplocks_on_change: breaking our own oplock.\n"));

			oplock_break_level2(new_fsp, True, token);

		} else {

			/*
			 * This is a remote file and so we send an asynchronous
			 * message.
			 */

			DEBUG(10,("release_level_2_oplocks_on_change: breaking remote oplock.\n"));
			request_oplock_break(share_entry, fsp->dev, fsp->inode);
		}
	}

	if (share_list)
		free((char *)share_list);
	unlock_share_entry_fsp(fsp);

	/* Paranoia check... */
	if (LEVEL_II_OPLOCK_TYPE(fsp->oplock_type)) {
		DEBUG(0,("release_level_2_oplocks_on_change: PANIC. File %s still has a level II oplock.\n", fsp->fsp_name));
		smb_panic("release_level_2_oplocks_on_change");
	}
}

/****************************************************************************
setup oplocks for this process
****************************************************************************/
BOOL init_oplocks(void)
{
	struct sockaddr_in sock_name;
	socklen_t len = sizeof(sock_name);

	DEBUG(3,("open_oplock_ipc: opening loopback UDP socket.\n"));

	/* Open a lookback UDP socket on a random port. */
	oplock_sock = open_socket_in(SOCK_DGRAM, 0, 0, htonl(INADDR_LOOPBACK),False);
	if (oplock_sock == -1) {
		DEBUG(0,("open_oplock_ipc: Failed to get local UDP socket for \
address %lx. Error was %s\n", (long)htonl(INADDR_LOOPBACK), strerror(errno)));
		global_oplock_port = 0;
		return(False);
	}

	/* Find out the transient UDP port we have been allocated. */
	if(getsockname(oplock_sock, (struct sockaddr *)&sock_name, &len)<0) {
		DEBUG(0,("open_oplock_ipc: Failed to get local UDP port. Error was %s\n",
			 strerror(errno)));
		close(oplock_sock);
		oplock_sock = -1;
		global_oplock_port = 0;
		return False;
	}
	global_oplock_port = ntohs(sock_name.sin_port);

	if (lp_kernel_oplocks()) {
#if HAVE_KERNEL_OPLOCKS_IRIX
		koplocks = irix_init_kernel_oplocks();
#elif HAVE_KERNEL_OPLOCKS_LINUX
		koplocks = linux_init_kernel_oplocks();
#endif
	}

	DEBUG(3,("open_oplock ipc: pid = %d, global_oplock_port = %u\n", 
		 (int)sys_getpid(), global_oplock_port));

	return True;
}