TeamTalk 5 .NET DLL  Version 5.9A
TeamTalkSrvBase.cs
1 /*
2  * Copyright (c) 2005-2018, BearWare.dk
3  *
4  * Contact Information:
5  *
6  * Bjoern D. Rasmussen
7  * Kirketoften 5
8  * DK-8260 Viby J
9  * Denmark
10  * Email: contact@bearware.dk
11  * Phone: +45 20 20 54 59
12  * Web: http://www.bearware.dk
13  *
14  * This source code is part of the TeamTalk SDK owned by
15  * BearWare.dk. Use of this file, or its compiled unit, requires a
16  * TeamTalk SDK License Key issued by BearWare.dk.
17  *
18  * The TeamTalk SDK License Agreement along with its Terms and
19  * Conditions are outlined in the file License.txt included with the
20  * TeamTalk SDK distribution.
21  *
22  */
23 
24 using System;
25 using System.Collections.Generic;
26 using System.Linq;
27 using System.Text;
28 using System.Runtime.InteropServices;
29 using c_tt;
30 using System.Collections;
31 using System.Reflection;
32 
33 namespace BearWare
34 {
37  public abstract class TeamTalkSrvBase : IDisposable
38  {
39  static IntPtr m_ttsInst;
40  public void Dispose()
41  {
42  deleteMe();
43  }
44 
45  private void deleteMe()
46  {
47  if (m_ttsInst != IntPtr.Zero)
48  {
49  TTProDLL.TTS_CloseTeamTalk(m_ttsInst);
50  m_ttsInst = IntPtr.Zero;
51  }
52  }
53  ~TeamTalkSrvBase()
54  {
55  deleteMe();
56  }
57 
78  public bool SetEncryptionContext(string szCertificateFile, string szPrivateKeyFile)
79  {
80  return TTProDLL.TTS_SetEncryptionContext(m_ttsInst, ref szCertificateFile, ref szPrivateKeyFile);
81  }
82 
100  public bool SetEncryptionContext(EncryptionContext lpEncryptionContext)
101  {
102  return TTProDLL.TTS_SetEncryptionContextEx(m_ttsInst, ref lpEncryptionContext);
103  }
104 
120  protected TeamTalkSrvBase()
121  {
122  m_ttsInst = TTProDLL.TTS_InitTeamTalk();
123  }
124  protected TeamTalkSrvBase(Channel lpChannel)
125  : this()
126  {
127  MakeChannel(lpChannel);
128  }
129  protected TeamTalkSrvBase(Channel lpChannel, ServerProperties lpServerProperties)
130  : this()
131  {
132  UpdateServer(lpServerProperties);
133  MakeChannel(lpChannel);
134  }
138  public void Close()
139  {
140  deleteMe();
141  }
148  public bool RunEventLoop(int pnWaitMs)
149  {
150  return TTProDLL.TTS_RunEventLoop(m_ttsInst, pnWaitMs);
151  }
169  public ClientError SetChannelFilesRoot(string szFilesRoot, Int64 nMaxDiskUsage, Int64 nDefaultChannelQuota)
170  {
171  return TTProDLL.TTS_SetChannelFilesRoot(m_ttsInst, szFilesRoot, nMaxDiskUsage, nDefaultChannelQuota);
172  }
186  public ClientError UpdateServer([In] BearWare.ServerProperties lpServerProperties)
187  {
188  return TTProDLL.TTS_UpdateServer(m_ttsInst, ref lpServerProperties);
189  }
202  public virtual ClientError MakeChannel(BearWare.Channel lpChannel)
203  {
204  return TTProDLL.TTS_MakeChannel(m_ttsInst, ref lpChannel);
205  }
215  public ClientError UpdateChannel(Channel lpChannel)
216  {
217  return TTProDLL.TTS_UpdateChannel(m_ttsInst, ref lpChannel);
218  }
227  public ClientError RemoveChannel(int nChannelID)
228  {
229  return TTProDLL.TTS_RemoveChannel(m_ttsInst, nChannelID);
230  }
243  public ClientError AddFileToChannel(string szLocalFilePath, BearWare.RemoteFile lpRemoteFile)
244  {
245  return TTProDLL.TTS_AddFileToChannel(m_ttsInst, ref szLocalFilePath, ref lpRemoteFile);
246  }
259  public ClientError RemoveFileFromChannel(RemoteFile lpRemoteFile)
260  {
261  return TTProDLL.TTS_RemoveFileFromChannel(m_ttsInst, ref lpRemoteFile);
262  }
271  public ClientError MoveUser(int nUserID, BearWare.Channel lpChannel)
272  {
273  return TTProDLL.TTS_MoveUser(m_ttsInst, nUserID, ref lpChannel);
274  }
283  public ClientError SendTextMessage(BearWare.TextMessage lpTextMessage)
284  {
285  return TTProDLL.TTS_SendTextMessage(m_ttsInst, ref lpTextMessage);
286  }
301  public bool StartServer(string szBindIPAddr, int nTcpPort, int nUdpPort, bool bEncrypted)
302  {
303  return TTProDLL.TTS_StartServer(m_ttsInst, szBindIPAddr, nTcpPort, nUdpPort, bEncrypted);
304  }
318  public bool StartServerSysID(string szBindIPAddr, int nTcpPort, int nUdpPort, bool bEncrypted,
319  string szSystemID)
320  {
321  return TTProDLL.TTS_StartServerSysID(m_ttsInst, szBindIPAddr, nTcpPort, nUdpPort, bEncrypted, szSystemID);
322  }
327  public bool StopServer()
328  {
329  return TTProDLL.TTS_StopServer(m_ttsInst);
330  }
331 
332  public static string GetVersion() { return Marshal.PtrToStringAuto(TTProDLL.TT_GetVersion()); }
333  class CallBack : IDisposable
334  {
335  private GCHandle hCallBack;
336  private IntPtr pCallFuncPointer;
337  Delegate lpCallback;
338  public CallBack(Delegate lpCallback)
339  {
340  this.lpCallback = lpCallback;
341  hCallBack = GCHandle.Alloc(lpCallback);
342  pCallFuncPointer = Marshal.GetFunctionPointerForDelegate(lpCallback);
343  GC.KeepAlive(lpCallback);
344  GC.Collect();
345  }
346  ~CallBack()
347  {
348  Dispose(true);
349  }
350 
351  public IntPtr GetFuncPointer()
352  {
353  return pCallFuncPointer;
354  }
355  public void Dispose()
356  {
357  GC.SuppressFinalize(this);
358  Dispose(true);
359  }
360  protected void Dispose(bool disposing)
361  {
362  if (disposing)
363  {
364  // Do Something
365  }
366  // free ressource
367  if (hCallBack.IsAllocated)
368  hCallBack.Free();
369  pCallFuncPointer = IntPtr.Zero;
370  }
371 
372  public bool Compare(Delegate x)
373  {
374  return Object.Equals(lpCallback, x);
375  }
376  }
377  private delegate bool DLL(IntPtr lpTTSInstance, IntPtr lpCallback, int lpUserData, bool bEnable);
378  private Dictionary<CallBack, DLL> Delegate2DLL = new Dictionary<CallBack, DLL>();
379  private bool RegisterServerCallback(Delegate lpCallback, int lpUserData, bool bEnable)
380  {
381  CallBack callBack = null;
382  bool b = false;
383  string TTProDLL_Method = "TTS_Register" + lpCallback.GetType().ToString().Split('+')[1];
384  MethodInfo method = typeof(TTProDLL).GetMethod(TTProDLL_Method);
385  DLL dg = (DLL)Delegate.CreateDelegate(typeof(DLL), method);
386 
387  foreach (KeyValuePair<CallBack, DLL> cb in Delegate2DLL)
388  {
389  if (cb.Key.Compare(lpCallback))
390  {
391  if (bEnable == true) return true;
392  callBack = cb.Key;
393  b = Delegate2DLL[callBack](m_ttsInst, callBack.GetFuncPointer(), 0, bEnable);
394  callBack.Dispose();
395  Delegate2DLL.Remove(callBack);
396  callBack = null;
397  return b;
398  }
399  }
400  if (callBack == null && bEnable)
401  {
402  callBack = new CallBack(lpCallback);
403  Delegate2DLL.Add(callBack, dg);
404  b = Delegate2DLL[callBack](m_ttsInst, callBack.GetFuncPointer(), 0, bEnable);
405  }
406  return b;
407  }
408  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
409  internal delegate void UserLoggedInCallback(IntPtr lpTTSInstance, [In] IntPtr lpUserData, [In] ref User lpUser);
410  private event UserLoggedInCallback onUserLoggedInCallback;
411  internal event UserLoggedInCallback OnUserLoggedInCallBack
412  {
413  add
414  {
415  lock (objectLock)
416  {
417  onUserLoggedInCallback += value;
418  RegisterServerCallback(value, 0, true);
419  }
420  }
421  remove
422  {
423  lock (objectLock)
424  {
425  onUserLoggedInCallback -= value;
426  RegisterServerCallback(value, 0, false);
427  }
428  }
429 
430  }
431 
432  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
433  internal delegate void UserChangeNicknameCallback(IntPtr lpTTSInstance, IntPtr lpUserData, [In, Out] ref ClientErrorMsg lpClientErrorMsg, ref User lpUser, [In] [MarshalAs(UnmanagedType.LPWStr)] string szNewNickname);
434  private event UserChangeNicknameCallback onUserChangeNicknameCallback;
435  internal event UserChangeNicknameCallback OnUserChangeNicknameCallback
436  {
437  add
438  {
439  lock(objectLock)
440  {
441  onUserChangeNicknameCallback += value;
442  RegisterServerCallback(value, 0, true);
443  }
444  }
445  remove
446  {
447  lock(objectLock)
448  {
449  onUserChangeNicknameCallback -= value;
450  RegisterServerCallback(value, 0, false);
451  }
452  }
453  }
454  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
455  internal delegate void UserChangeStatusCallback(IntPtr lpTTSInstance, IntPtr lpUserData, [In,Out] ref ClientErrorMsg lpClientErrorMsg, [In] ref User lpUser, [In] ref int nNewStatusMode, [In] [MarshalAs(UnmanagedType.LPWStr)] string szNewStatusMsg);
456  private event UserChangeStatusCallback onUserChangeStatusCallback;
457  internal event UserChangeStatusCallback OnUserChangeStatusCallback
458  {
459  add
460  {
461  lock(objectLock)
462  {
463  onUserChangeStatusCallback += value;
464  RegisterServerCallback(value, 0, true);
465  }
466  }
467  remove
468  {
469  lock (objectLock)
470  {
471  onUserChangeStatusCallback -= value;
472  RegisterServerCallback(value, 0, false);
473  }
474  }
475  }
476 
477  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
478  internal delegate void UserLoginCallback(IntPtr lpTTSInstance, IntPtr lpUserData, [In, Out] ref ClientErrorMsg lpClientErrorMsg, ref User lpUser, [In, Out]ref UserAccount lpUserAccount);
479  object objectLock = new Object();
480  private event UserLoginCallback onUserLoginCallback;
481  internal event UserLoginCallback OnUserLoginCallback
482  {
483  add
484  {
485  lock (objectLock)
486  {
487  onUserLoginCallback += value;
488  RegisterServerCallback(value, 0, true);
489  }
490  }
491  remove
492  {
493  lock (objectLock)
494  {
495  onUserLoginCallback -= value;
496  RegisterServerCallback(value, 0, false);
497  }
498  }
499  }
500  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
501  internal delegate void UserCreateUserAccountCallback(IntPtr lpTTSInstance, IntPtr lpUserData, [In, Out] ref ClientErrorMsg lpClientErrorMsg, ref User lpUser, [In, Out]ref UserAccount lpUserAccount);
502  private event UserCreateUserAccountCallback onUserCreateUserAccountCallback;
503  internal event UserCreateUserAccountCallback OnUserCreateUserAccountCallback
504  {
505  add
506  {
507  onUserCreateUserAccountCallback += value;
508  RegisterServerCallback(value, 0, true);
509  }
510  remove
511  {
512  onUserCreateUserAccountCallback -= value;
513  RegisterServerCallback(value, 0, false);
514  }
515  }
516  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
517  internal delegate void UserDeleteUserAccountCallback(IntPtr lpTTSInstance, IntPtr lpUserData, [In, Out] ref ClientErrorMsg lpClientErrorMsg, ref User lpUser, [In] [MarshalAs(UnmanagedType.LPWStr)] string szUsername);
518  private event UserDeleteUserAccountCallback onUserDeleteUserAccountCallback;
519  internal event UserDeleteUserAccountCallback OnUserDeleteUserAccountCallback
520  {
521  add
522  {
523  onUserDeleteUserAccountCallback += value;
524  RegisterServerCallback(value, 0, true);
525  }
526  remove
527  {
528  onUserDeleteUserAccountCallback -= value;
529  RegisterServerCallback(value, 0, false);
530  }
531  }
532  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
533  internal delegate void UserAddServerBanCallback(IntPtr lpTTSInstance, IntPtr lpUserData, [In, Out] ref ClientErrorMsg lpClientErrorMsg, [In,Out] ref User lpBanner, [In,Out] ref User lpBanee);
534  private event UserAddServerBanCallback onUserAddServerBanCallback;
535  internal event UserAddServerBanCallback OnUserAddServerBanCallback
536  {
537  add
538  {
539  onUserAddServerBanCallback += value;
540  RegisterServerCallback(value, 0, true);
541  }
542  remove
543  {
544  onUserAddServerBanCallback -= value;
545  RegisterServerCallback(value, 0, false);
546  }
547  }
548  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
549  internal delegate void UserAddServerBanIPAddressCallback(IntPtr lpTTSInstance,
550  IntPtr lpUserData,
551  [In, Out] ref ClientErrorMsg lpClientErrorMsg,
552  [In] ref User lpBanner,
553  [In,Out] [MarshalAs(UnmanagedType.LPWStr)] string szIPAddress);
554  private event UserAddServerBanIPAddressCallback onUserAddServerBanIPAddressCallback;
555  internal event UserAddServerBanIPAddressCallback OnUserAddServerBanIPAddressCallback
556  {
557  add
558  {
559  onUserAddServerBanIPAddressCallback += value;
560  RegisterServerCallback(value, 0, true);
561  }
562  remove
563  {
564  onUserAddServerBanIPAddressCallback -= value;
565  RegisterServerCallback(value, 0, false);
566  }
567  }
568  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
569  internal delegate void UserDeleteServerBanCallback(IntPtr lpTTSInstance,
570  IntPtr lpUserData,
571  [In, Out] ref ClientErrorMsg lpClientErrorMsg,
572  [In] ref User lpUser,
573  [In] [MarshalAs(UnmanagedType.LPWStr)] string szIPAddress);
574  private event UserDeleteServerBanCallback onUserDeleteServerBanCallback;
575  internal event UserDeleteServerBanCallback OnUserDeleteServerBanCallback
576  {
577  add
578  {
579  onUserDeleteServerBanCallback += value;
580  RegisterServerCallback(value, 0, true);
581  }
582  remove
583  {
584  onUserDeleteServerBanCallback -= value;
585  RegisterServerCallback(value, 0, false);
586  }
587  }
588  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
589  internal delegate void UserConnectedCallback(IntPtr lpTTSInstance,
590  IntPtr lpUserData, [In] ref User lpUser);
591  private event UserConnectedCallback onUserConnectedCallback;
592  internal event UserConnectedCallback OnUserConnectedCallback
593  {
594  add
595  {
596  onUserConnectedCallback += value;
597  RegisterServerCallback(value, 0, true);
598  }
599  remove
600  {
601  onUserConnectedCallback -= value;
602  RegisterServerCallback(value, 0, false);
603  }
604  }
605  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
606  internal delegate void UserLoggedOutCallback(IntPtr lpTTSInstance,
607  IntPtr lpUserData, [In] ref User lpUser);
608  private event UserLoggedOutCallback onUserLoggedOutCallback;
609  internal event UserLoggedOutCallback OnUserLoggedOutCallback
610  {
611  add
612  {
613  onUserLoggedOutCallback += value;
614  RegisterServerCallback(value, 0, true);
615  }
616  remove
617  {
618  onUserLoggedOutCallback -= value;
619  RegisterServerCallback(value, 0, false);
620  }
621  }
622  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
623  internal delegate void UserDisconnectedCallback(IntPtr lpTTSInstance,
624  IntPtr lpUserData, [In] ref User lpUser);
625  private event UserDisconnectedCallback onUserDisconnectedCallback;
626  internal event UserDisconnectedCallback OnUserDisconnectedCallback
627  {
628  add
629  {
630  onUserDisconnectedCallback += value;
631  RegisterServerCallback(value, 0, true);
632  }
633  remove
634  {
635  onUserDisconnectedCallback -= value;
636  RegisterServerCallback(value, 0, false);
637  }
638  }
639  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
640  internal delegate void UserTimedoutCallback(IntPtr lpTTSInstance,
641  IntPtr lpUserData, [In] ref User lpUser);
642  private event UserTimedoutCallback onUserTimedoutCallback;
643  internal event UserTimedoutCallback OnUserTimedoutCallback
644  {
645  add
646  {
647  onUserTimedoutCallback += value;
648  RegisterServerCallback(value, 0, true);
649  }
650  remove
651  {
652  onUserTimedoutCallback -= value;
653  RegisterServerCallback(value, 0, false);
654  }
655  }
656  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
657  internal delegate void UserKickedCallback(IntPtr lpTTSInstance,
658  IntPtr lpUserData, IntPtr lpKicker,
659  [In] ref User lpKickee, [In] IntPtr lpChannel);
660  private event UserKickedCallback onUserKickedCallback;
661  internal event UserKickedCallback OnUserKickedCallback
662  {
663  add
664  {
665  onUserKickedCallback += value;
666  RegisterServerCallback(value, 0, true);
667  }
668  remove
669  {
670  onUserKickedCallback -= value;
671  RegisterServerCallback(value, 0, false);
672  }
673  }
674  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
675  internal delegate void UserBannedCallback(IntPtr lpTTSInstance,IntPtr lpUserData, [In,Out] ref User lpBanner,[In,Out] ref User lpBanee, IntPtr lpChannel);
676  private event UserBannedCallback onUserBannedCallback;
677  internal event UserBannedCallback OnUserBannedCallback
678  {
679  add
680  {
681  onUserBannedCallback += value;
682  RegisterServerCallback(value, 0, true);
683  }
684  remove
685  {
686  onUserBannedCallback -= value;
687  RegisterServerCallback(value, 0, false);
688  }
689  }
690  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
691  internal delegate void UserUnbannedCallback(IntPtr lpTTSInstance,
692  IntPtr lpUserData, [In] ref User lpUnbanner,
693  [In] [MarshalAs(UnmanagedType.LPWStr)] string szIPAddress);
694  private event UserUnbannedCallback onUserUnbannedCallback;
695  internal event UserUnbannedCallback OnUserUnbannedCallback
696  {
697  add
698  {
699  onUserUnbannedCallback += value;
700  RegisterServerCallback(value, 0, true);
701  }
702  remove
703  {
704  onUserUnbannedCallback -= value;
705  RegisterServerCallback(value, 0, false);
706  }
707  }
708  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
709  internal delegate void UserUpdatedCallback(IntPtr lpTTSInstance,
710  IntPtr lpUserData, [In] ref User lpUser);
711  private event UserUpdatedCallback onUserUpdatedCallback;
712  internal event UserUpdatedCallback OnUserUpdatedCallback
713  {
714  add
715  {
716  onUserUpdatedCallback += value;
717  RegisterServerCallback(value, 0, true);
718  }
719  remove
720  {
721  onUserUpdatedCallback -= value;
722  RegisterServerCallback(value, 0, false);
723  }
724  }
725  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
726  internal delegate void UserJoinedChannelCallback(IntPtr lpTTSInstance,
727  IntPtr lpUserData, [In, Out] ref User lpUser,
728  [In,Out] ref Channel lpChannel);
729  private event UserJoinedChannelCallback onUserJoinedChannelCallback;
730  internal event UserJoinedChannelCallback OnUserJoinedChannelCallback
731  {
732  add
733  {
734  onUserJoinedChannelCallback += value;
735  RegisterServerCallback(value, 0, true);
736  }
737  remove
738  {
739  onUserJoinedChannelCallback -= value;
740  RegisterServerCallback(value, 0, false);
741  }
742  }
743  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
744  internal delegate void UserLeftChannelCallback(IntPtr lpTTSInstance,
745  IntPtr lpUserData, [In,Out] ref User lpUser,
746  [In,Out] ref Channel lpChannel);
747  private event UserLeftChannelCallback onUserLeftChannelCallback;
748  internal event UserLeftChannelCallback OnUserLeftChannelCallback
749  {
750  add
751  {
752  onUserLeftChannelCallback += value;
753  RegisterServerCallback(value, 0, true);
754  }
755  remove
756  {
757  onUserLeftChannelCallback -= value;
758  RegisterServerCallback(value, 0, false);
759  }
760  }
761  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
762  internal delegate void UserMovedCallback(IntPtr lpTTSInstance,
763  IntPtr lpUserData, [In,Out] ref User lpMover,
764  [In,Out] ref User lpMovee);
765  private event UserMovedCallback onUserMovedCallback;
766  internal event UserMovedCallback OnUserMovedCallback
767  {
768  add
769  {
770  onUserMovedCallback += value;
771  RegisterServerCallback(value, 0, true);
772  }
773  remove
774  {
775  onUserMovedCallback -= value;
776  RegisterServerCallback(value, 0, false);
777  }
778  }
779  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
780  internal delegate void UserTextMessageCallback(IntPtr lpTTSInstance,
781  IntPtr lpUserData, [In] ref User lpUser,
782  [In] ref TextMessage lpTextMessage);
783  private event UserTextMessageCallback onUserTextMessageCallback;
784  internal event UserTextMessageCallback OnUserTextMessageCallback
785  {
786  add
787  {
788  onUserTextMessageCallback += value;
789  RegisterServerCallback(value, 0, true);
790  }
791  remove
792  {
793  onUserTextMessageCallback -= value;
794  RegisterServerCallback(value, 0, false);
795  }
796  }
797  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
798  internal delegate void ChannelCreatedCallback(IntPtr lpTTSInstance,
799  IntPtr lpUserData,[In] ref Channel lpChannel,
800  IntPtr lpUser);
801  private event ChannelCreatedCallback onChannelCreatedCallback;
802  internal event ChannelCreatedCallback OnChannelCreatedCallback
803  {
804  add
805  {
806  onChannelCreatedCallback += value;
807  RegisterServerCallback(value, 0, true);
808  }
809  remove
810  {
811  onChannelCreatedCallback -= value;
812  RegisterServerCallback(value, 0, false);
813  }
814  }
815  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
816  internal delegate void ChannelUpdatedCallback(IntPtr lpTTSInstance,
817  IntPtr lpUserData, [In] ref Channel lpChannel,
818  IntPtr lpUser);
819  private event ChannelUpdatedCallback onChannelUpdatedCallback;
820  internal event ChannelUpdatedCallback OnChannelUpdatedCallback
821  {
822  add
823  {
824  onChannelUpdatedCallback += value;
825  RegisterServerCallback(value, 0, true);
826  }
827  remove
828  {
829  onChannelUpdatedCallback -= value;
830  RegisterServerCallback(value, 0, false);
831  }
832  }
833  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
834  internal delegate void ChannelRemovedCallback(IntPtr lpTTSInstance,
835  IntPtr lpUserData, [In] ref Channel lpChannel,
836  IntPtr lpUser);
837  private event ChannelRemovedCallback onChannelRemovedCallback;
838  internal event ChannelRemovedCallback OnChannelRemovedCallback
839  {
840  add
841  {
842  onChannelRemovedCallback += value;
843  RegisterServerCallback(value, 0, true);
844  }
845  remove
846  {
847  onChannelRemovedCallback -= value;
848  RegisterServerCallback(value, 0, false);
849  }
850  }
851  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
852  internal delegate void FileUploadedCallback(IntPtr lpTTSInstance,
853  IntPtr lpUserData,
854  [In] ref RemoteFile lpRemoteFile,
855  [In] ref User lpUser);
856  private event FileUploadedCallback onFileUploadedCallback;
857  internal event FileUploadedCallback OnFileUploadedCallback
858  {
859  add
860  {
861  onFileUploadedCallback += value;
862  RegisterServerCallback(value, 0, true);
863  }
864  remove
865  {
866  onFileUploadedCallback -= value;
867  RegisterServerCallback(value, 0, false);
868  }
869  }
870  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
871  internal delegate void FileDownloadedCallback(IntPtr lpTTSInstance,
872  IntPtr lpUserData,
873  [In] ref RemoteFile lpRemoteFile,
874  [In] ref User lpUser);
875  private event FileDownloadedCallback onFileDownloadedCallback;
876  internal event FileDownloadedCallback OnFileDownloadedCallback
877  {
878  add
879  {
880  onFileDownloadedCallback += value;
881  RegisterServerCallback(value, 0, true);
882  }
883  remove
884  {
885  onFileDownloadedCallback -= value;
886  RegisterServerCallback(value, 0, false);
887  }
888  }
889  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
890  internal delegate void FileDeletedCallback(IntPtr lpTTSInstance,
891  IntPtr lpUserData,
892  [In] ref RemoteFile lpRemoteFile,
893  [In] ref User lpUser);
894  private event FileDeletedCallback onFileDeletedCallback;
895  internal event FileDeletedCallback OnFileDeletedCallback
896  {
897  add
898  {
899  onFileDeletedCallback += value;
900  RegisterServerCallback(value, 0, true);
901  }
902  remove
903  {
904  onFileDeletedCallback -= value;
905  RegisterServerCallback(value, 0, false);
906  }
907  }
908  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
909  internal delegate void ServerUpdatedCallback(IntPtr lpTTSInstance,
910  IntPtr lpUserData,
911  [In] ref ServerProperties lpServerProperties,
912  [In] ref User lpUser);
913  private event ServerUpdatedCallback onServerUpdatedCallback;
914  internal event ServerUpdatedCallback OnServerUpdatedCallback
915  {
916  add
917  {
918  onServerUpdatedCallback += value;
919  RegisterServerCallback(value, 0, true);
920  }
921  remove
922  {
923  onServerUpdatedCallback -= value;
924  RegisterServerCallback(value, 0, false);
925  }
926  }
927  [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
928  internal delegate void SaveServerConfigCallback(IntPtr lpTTSInstance,
929  IntPtr lpUserData,
930  IntPtr lpUser);
931  private event SaveServerConfigCallback onSaveServerConfigCallback;
932  internal event SaveServerConfigCallback OnSaveServerConfigCallback
933  {
934  add
935  {
936  onSaveServerConfigCallback += value;
937  RegisterServerCallback(value, 0, true);
938  }
939  remove
940  {
941  onSaveServerConfigCallback -= value;
942  RegisterServerCallback(value, 0, false);
943  }
944  }
945 
946  }
947 
948 }
BearWare.TeamTalkSrvBase
Base class for BearWare.TeamTalk5Srv.
Definition: TeamTalkSrvBase.cs:38
BearWare.ClientError
ClientError
Errors which can occur either as a result of client commands or as a result of internal errors.
Definition: TeamTalk.cs:3029
BearWare.TeamTalkSrvBase.CallBack.Dispose
void Dispose()
Definition: TeamTalkSrvBase.cs:355
BearWare.TeamTalkSrvBase.Close
void Close()
Close TeamTalk server instance.
Definition: TeamTalkSrvBase.cs:138
BearWare.TeamTalkSrvBase.GetVersion
static string GetVersion()
Definition: TeamTalkSrvBase.cs:332
BearWare.TeamTalkSrvBase.SetEncryptionContext
bool SetEncryptionContext(EncryptionContext lpEncryptionContext)
Set up encryption context for encrypted server.
Definition: TeamTalkSrvBase.cs:100
BearWare.TeamTalkSrvBase.CallBack.CallBack
CallBack(Delegate lpCallback)
Definition: TeamTalkSrvBase.cs:338
BearWare.TeamTalkSrvBase.UpdateServer
ClientError UpdateServer([In] BearWare.ServerProperties lpServerProperties)
Set server properties.
Definition: TeamTalkSrvBase.cs:186
BearWare.TeamTalkSrvBase.TeamTalkSrvBase
TeamTalkSrvBase(Channel lpChannel)
Definition: TeamTalkSrvBase.cs:124
BearWare.TeamTalkSrvBase.RunEventLoop
bool RunEventLoop(int pnWaitMs)
Run the server's event loop.
Definition: TeamTalkSrvBase.cs:148
BearWare.TeamTalkSrvBase.MakeChannel
virtual ClientError MakeChannel(BearWare.Channel lpChannel)
Make new channel.
Definition: TeamTalkSrvBase.cs:202
BearWare.TeamTalkSrvBase.CallBack.Dispose
void Dispose(bool disposing)
Definition: TeamTalkSrvBase.cs:360
BearWare.TeamTalkSrvBase.SetChannelFilesRoot
ClientError SetChannelFilesRoot(string szFilesRoot, Int64 nMaxDiskUsage, Int64 nDefaultChannelQuota)
The root folder of where users should upload files to.
Definition: TeamTalkSrvBase.cs:169
BearWare.TeamTalkSrvBase.SendTextMessage
ClientError SendTextMessage(BearWare.TextMessage lpTextMessage)
Send text message from server to clients.
Definition: TeamTalkSrvBase.cs:283
BearWare.TeamTalkSrvBase.StartServerSysID
bool StartServerSysID(string szBindIPAddr, int nTcpPort, int nUdpPort, bool bEncrypted, string szSystemID)
Same as StartServer() but with the option of specifying a system-ID.
Definition: TeamTalkSrvBase.cs:318
BearWare.TeamTalkSrvBase.TeamTalkSrvBase
TeamTalkSrvBase(Channel lpChannel, ServerProperties lpServerProperties)
Definition: TeamTalkSrvBase.cs:129
BearWare.TeamTalkSrvBase.RemoveChannel
ClientError RemoveChannel(int nChannelID)
Remove a channel.
Definition: TeamTalkSrvBase.cs:227
BearWare.TeamTalkSrvBase.AddFileToChannel
ClientError AddFileToChannel(string szLocalFilePath, BearWare.RemoteFile lpRemoteFile)
Add a file to an existing channel.
Definition: TeamTalkSrvBase.cs:243
BearWare.TeamTalkSrvBase.RemoveFileFromChannel
ClientError RemoveFileFromChannel(RemoteFile lpRemoteFile)
Remove a file from a channel.
Definition: TeamTalkSrvBase.cs:259
BearWare.TeamTalkSrvBase.StopServer
bool StopServer()
Stop server and drop all users.
Definition: TeamTalkSrvBase.cs:327
BearWare.TeamTalkSrvBase.MoveUser
ClientError MoveUser(int nUserID, BearWare.Channel lpChannel)
Move a user from one channel to another.
Definition: TeamTalkSrvBase.cs:271
BearWare.TeamTalkSrvBase.TeamTalkSrvBase
TeamTalkSrvBase()
Create new TeamTalk server instance.
Definition: TeamTalkSrvBase.cs:120
BearWare.TeamTalkSrvBase.StartServer
bool StartServer(string szBindIPAddr, int nTcpPort, int nUdpPort, bool bEncrypted)
Start server on specified IP-address and ports.
Definition: TeamTalkSrvBase.cs:301
BearWare.TeamTalkSrvBase.CallBack.GetFuncPointer
IntPtr GetFuncPointer()
Definition: TeamTalkSrvBase.cs:351
BearWare.TeamTalkSrvBase.UpdateChannel
ClientError UpdateChannel(Channel lpChannel)
Update an existing channel.
Definition: TeamTalkSrvBase.cs:215
BearWare.TeamTalkSrvBase.SetEncryptionContext
bool SetEncryptionContext(string szCertificateFile, string szPrivateKeyFile)
Set certificate and private key for encrypted server.
Definition: TeamTalkSrvBase.cs:78
BearWare.TeamTalkSrvBase.CallBack.Compare
bool Compare(Delegate x)
Definition: TeamTalkSrvBase.cs:372
BearWare.Channel
A struct containing the properties of a channel.
Definition: TeamTalk.cs:2579
BearWare.EncryptionContext
Configure peer verification for encrypted connection.
Definition: TeamTalk.cs:2832
BearWare.RemoteFile
A struct containing the properties of a file in a BearWare.Channel.
Definition: TeamTalk.cs:2802
BearWare.ServerProperties
A struct containing the properties of the server's settings.
Definition: TeamTalk.cs:1877
BearWare.TextMessage
A struct containing the properties of a text message sent by a user.
Definition: TeamTalk.cs:2501