mcs/class/System/Test/System.Net/DnsCas.cs

   1 //
   2 // DnsCas.cs - CAS unit tests for System.Net.Dns class
   3 //
   4 // Author:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
   8 //
   9
  10 using NUnit.Framework;
  11
  12 using System;
  13 using System.Net;
  14 using System.Security;
  15 using System.Security.Permissions;
  16 using System.Threading;
  17
  18 namespace MonoCasTests.System.Net {
  19
  20         [TestFixture]
  21         [Category ("CAS")]
  22         [Category ("NotWorking")] // compiler (CSC) issue (on Windows)
  23         public class DnsCas {
  24
  25                 private const string site = "www.go-mono.com";
  26                 private const int timeout = 30000;
  27
  28                 static ManualResetEvent reset;
  29                 private string message;
  30                 private string hostname;
  31                 private IPAddress ip;
  32
  33                 [TestFixtureSetUp]
  34                 public void FixtureSetUp ()
  35                 {
  36                         reset = new ManualResetEvent (false);
  37                         hostname = Dns.GetHostName ();
  38                         ip = Dns.Resolve (site).AddressList[0];
  39                 }
  40
  41                 [TestFixtureTearDown]
  42                 public void FixtureTearDown ()
  43                 {
  44                         reset.Close ();
  45                 }
  46
  47                 [SetUp]
  48                 public void SetUp ()
  49                 {
  50                         if (!SecurityManager.SecurityEnabled)
  51                                 Assert.Ignore ("SecurityManager.SecurityEnabled is OFF");
  52                 }
  53
  54                 // test Demand by denying it's caller from the required permission
  55
  56                 [Test]
  57                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
  58                 [ExpectedException (typeof (SecurityException))]
  59                 public void Deny_BeginGetHostName ()
  60                 {
  61                         Dns.BeginGetHostByName (null, null, null);
  62                 }
  63
  64                 [Test]
  65                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
  66                 [ExpectedException (typeof (ArgumentNullException))]
  67                 public void Deny_EndGetHostByName ()
  68                 {
  69                         Dns.EndGetHostByName (null);
  70                 }
  71
  72                 [Test]
  73                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
  74                 [ExpectedException (typeof (SecurityException))]
  75                 public void Deny_BeginResolve ()
  76                 {
  77                         Dns.BeginResolve (null, null, null);
  78                 }
  79
  80                 [Test]
  81                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
  82                 [ExpectedException (typeof (ArgumentNullException))]
  83                 public void Deny_EndResolve ()
  84                 {
  85                         Dns.EndResolve (null);
  86                 }
  87
  88                 [Test]
  89                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
  90                 [ExpectedException (typeof (SecurityException))]
  91                 public void Deny_GetHostByAddress_IPAddress ()
  92                 {
  93                         Dns.GetHostByAddress ((IPAddress)null);
  94                 }
  95
  96                 [Test]
  97                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
  98                 [ExpectedException (typeof (SecurityException))]
  99                 public void Deny_GetHostByAddress_String ()
 100                 {
 101                         Dns.GetHostByAddress ((string)null);
 102                 }
 103
 104                 [Test]
 105                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 106                 [ExpectedException (typeof (SecurityException))]
 107                 public void Deny_GetHostByName ()
 108                 {
 109                         Dns.GetHostByName (site);
 110                 }
 111
 112                 [Test]
 113                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 114 #if NET_2_0
 115                 [ExpectedException (typeof (ArgumentNullException))]
 116                 // so it's not a declarative attribute on the method as the
 117                 // null check is done before throwing the SecurityException
 118 #else
 119                 [ExpectedException (typeof (SecurityException))]
 120 #endif
 121                 public void Deny_GetHostByName_Null ()
 122                 {
 123                         Dns.GetHostByName (null);
 124                 }
 125
 126                 [Test]
 127                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 128                 [ExpectedException (typeof (SecurityException))]
 129                 public void Deny_GetHostByName_HostName ()
 130                 {
 131                         // ... so my first guess is that you can only query
 132                         // yourself without having unrestricted DnsPermission
 133                         Assert.IsNotNull (Dns.GetHostByName (hostname));
 134                         // but that's wrong :-(
 135                 }
 136
 137                 [Test]
 138                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 139                 [ExpectedException (typeof (SecurityException))]
 140                 public void Deny_GetHostName ()
 141                 {
 142                         Dns.GetHostName ();
 143                 }
 144
 145                 [Test]
 146                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 147                 [ExpectedException (typeof (SecurityException))]
 148                 public void Deny_Resolve ()
 149                 {
 150                         Dns.Resolve (null);
 151                 }
 152
 153 #if NET_2_0
 154                 // TODO: New 2.0 methods aren't yet implemented in Mono
 155 /*
 156                 [Test]
 157                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 158                 [ExpectedException (typeof (SecurityException))]
 159                 public void Deny_BeginGetHostAddresses ()
 160                 {
 161                         Dns.BeginGetHostAddresses (null, null, null);
 162                 }
 163
 164                 [Test]
 165                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 166                 [ExpectedException (typeof (ArgumentNullException))]
 167                 public void Deny_EndGetHostAddresses ()
 168                 {
 169                         Dns.EndGetHostAddresses (null);
 170                 }
 171
 172                 [Test]
 173                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 174                 [ExpectedException (typeof (SecurityException))]
 175                 public void Deny_BeginGetHostEntry_IPAddress ()
 176                 {
 177                         Dns.BeginGetHostEntry ((IPAddress)null, null, null);
 178                 }
 179
 180                 [Test]
 181                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 182                 [ExpectedException (typeof (SecurityException))]
 183                 public void Deny_BeginGetHostEntry_String ()
 184                 {
 185                         Dns.BeginGetHostEntry ((string)null, null, null);
 186                 }
 187
 188                 [Test]
 189                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 190                 [ExpectedException (typeof (ArgumentNullException))]
 191                 public void Deny_EndGetHostEntry ()
 192                 {
 193                         Dns.EndGetHostEntry (null);
 194                 }
 195
 196                 [Test]
 197                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 198                 [ExpectedException (typeof (SecurityException))]
 199                 public void Deny_GetHostEntry_IPAddress ()
 200                 {
 201                         Dns.GetHostEntry ((IPAddress)null);
 202                 }
 203
 204                 [Test]
 205                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 206                 [ExpectedException (typeof (SecurityException))]
 207                 public void Deny_GetHostEntry_String ()
 208                 {
 209                         Dns.GetHostEntry ((string)null);
 210                 }
 211
 212                 [Test]
 213                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 214                 [ExpectedException (typeof (SecurityException))]
 215                 public void Deny_GetHostAddresses ()
 216                 {
 217                         Dns.GetHostAddresses (null);
 218                 }
 219 */
 220 #endif
 221
 222                 // ensure that only DnsPermission is required to call the methods
 223
 224                 [Test]
 225                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 226                 [ExpectedException (typeof (ArgumentNullException))]
 227                 public void PermitOnly_BeginGetHostName ()
 228                 {
 229                         Dns.BeginGetHostByName (null, null, null);
 230                 }
 231
 232                 [Test]
 233                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 234                 [ExpectedException (typeof (ArgumentNullException))]
 235                 public void PermitOnly_BeginResolve ()
 236                 {
 237                         Dns.BeginResolve (null, null, null);
 238                 }
 239
 240                 [Test]
 241                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 242                 [ExpectedException (typeof (ArgumentNullException))]
 243                 public void PermitOnly_GetHostByAddress_IPAddress ()
 244                 {
 245                         Dns.GetHostByAddress ((IPAddress)null);
 246                 }
 247
 248                 [Test]
 249                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 250                 [ExpectedException (typeof (ArgumentNullException))]
 251                 public void PermitOnly_GetHostByAddress_String ()
 252                 {
 253                         Dns.GetHostByAddress ((string)null);
 254                 }
 255
 256                 [Test]
 257                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 258                 [ExpectedException (typeof (ArgumentNullException))]
 259                 public void PermitOnly_GetHostByName ()
 260                 {
 261                         Dns.GetHostByName (null);
 262                 }
 263
 264                 [Test]
 265                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 266                 public void PermitOnly_GetHostName ()
 267                 {
 268                         Assert.IsNotNull (Dns.GetHostName ());
 269                 }
 270
 271                 [Test]
 272                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 273                 [ExpectedException (typeof (ArgumentNullException))]
 274                 public void PermitOnly_Resolve ()
 275                 {
 276                         Dns.Resolve (null);
 277                 }
 278
 279 #if NET_2_0
 280                 // TODO: New 2.0 methods aren't yet implemented in Mono
 281 /*
 282                 [Test]
 283                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 284                 [ExpectedException (typeof (ArgumentNullException))]
 285                 public void PermitOnly_BeginGetHostAddresses ()
 286                 {
 287                         Dns.BeginGetHostAddresses (null, null, null);
 288                 }
 289
 290                 [Test]
 291                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 292                 [ExpectedException (typeof (ArgumentNullException))]
 293                 public void PermitOnly_EndGetHostAddresses ()
 294                 {
 295                         Dns.EndGetHostAddresses (null);
 296                 }
 297
 298                 [Test]
 299                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 300                 [ExpectedException (typeof (ArgumentNullException))]
 301                 public void PermitOnly_BeginGetHostEntry_IPAddress ()
 302                 {
 303                         Dns.BeginGetHostEntry ((IPAddress)null, null, null);
 304                 }
 305
 306                 [Test]
 307                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 308                 [ExpectedException (typeof (ArgumentNullException))]
 309                 public void PermitOnly_BeginGetHostEntry_String ()
 310                 {
 311                         Dns.BeginGetHostEntry ((string)null, null, null);
 312                 }
 313
 314                 [Test]
 315                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 316                 [ExpectedException (typeof (ArgumentNullException))]
 317                 public void PermitOnly_EndGetHostEntry ()
 318                 {
 319                         Dns.EndGetHostEntry (null);
 320                 }
 321
 322                 [Test]
 323                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 324                 [ExpectedException (typeof (ArgumentNullException))]
 325                 public void PermitOnly_GetHostEntry_IPAddress ()
 326                 {
 327                         Dns.GetHostEntry ((IPAddress)null);
 328                 }
 329
 330                 [Test]
 331                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 332                 [ExpectedException (typeof (ArgumentNullException))]
 333                 public void PermitOnly_GetHostEntry_String ()
 334                 {
 335                         Dns.GetHostEntry ((string)null);
 336                 }
 337
 338                 [Test]
 339                 [DnsPermission (SecurityAction.PermitOnly, Unrestricted = true)]
 340                 [ExpectedException (typeof (ArgumentNullException))]
 341                 public void PermitOnly_GetHostAddresses ()
 342                 {
 343                         Dns.GetHostAddresses (null);
 344                 }
 345 */
 346 #endif
 347
 348                 // async tests (for stack propagation)
 349
 350                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 351                 private void GetHostByNameCallback (IAsyncResult ar)
 352                 {
 353                         Dns.EndGetHostByName (ar);
 354                         try {
 355                                 // can we do something bad here ?
 356                                 Assert.IsNotNull (Environment.GetEnvironmentVariable ("USERNAME"));
 357                                 message = "Expected a SecurityException";
 358                         }
 359                         catch (SecurityException) {
 360                                 message = null;
 361                                 reset.Set ();
 362                         }
 363                         catch (Exception e)
 364                         {
 365                                 message = e.ToString ();
 366                         }
 367                 }
 368
 369                 [Test]
 370                 [EnvironmentPermission (SecurityAction.Deny, Read = "USERNAME")]
 371                 public void AsyncGetHostByName ()
 372                 {
 373                         message = "AsyncGetHostByName";
 374                         reset.Reset ();
 375                         IAsyncResult r = Dns.BeginGetHostByName (site, new AsyncCallback (GetHostByNameCallback), null);
 376                         Assert.IsNotNull (r, "IAsyncResult");
 377                         // note for some reason r.AsyncWaitHandle.Wait won't work as expected
 378                         // if (!r.AsyncWaitHandle.WaitOne (timeout, true))
 379                         if (!reset.WaitOne (timeout, true))
 380                                 Assert.Ignore ("Timeout");
 381                         Assert.IsNull (message, message);
 382                 }
 383
 384                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 385                 private void ResolveCallback (IAsyncResult ar)
 386                 {
 387                         Dns.EndResolve (ar);
 388                         try {
 389                                 // can we do something bad here ?
 390                                 Assert.IsNotNull (Environment.GetEnvironmentVariable ("USERNAME"));
 391                                 message = "Expected a SecurityException";
 392                         }
 393                         catch (SecurityException) {
 394                                 message = null;
 395                                 reset.Set ();
 396                         }
 397                         catch (Exception e) {
 398                                 message = e.ToString ();
 399                         }
 400                 }
 401
 402                 [Test]
 403                 [EnvironmentPermission (SecurityAction.Deny, Read = "USERNAME")]
 404                 public void AsyncResolve ()
 405                 {
 406                         message = "AsyncResolve";
 407                         reset.Reset ();
 408                         IAsyncResult r = Dns.BeginResolve (site, new AsyncCallback (ResolveCallback), null);
 409                         Assert.IsNotNull (r, "IAsyncResult");
 410                         // note for some reason r.AsyncWaitHandle.Wait won't work as expected
 411                         // if (!r.AsyncWaitHandle.WaitOne (timeout, true))
 412                         if (!reset.WaitOne (timeout, true))
 413                                 Assert.Ignore ("Timeout");
 414                         Assert.IsNull (message, message);
 415                 }
 416
 417 #if NET_2_0
 418                 // TODO: New 2.0 methods aren't yet implemented in Mono
 419 /*
 420                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 421                 private void GetHostEntryCallback (IAsyncResult ar)
 422                 {
 423                         Dns.EndGetHostEntry (ar);
 424                         try {
 425                                 // can we do something bad here ?
 426                                 Assert.IsNotNull (Environment.GetEnvironmentVariable ("USERNAME"));
 427                                 message = "Expected a SecurityException";
 428                         }
 429                         catch (SecurityException) {
 430                                 message = null;
 431                                 reset.Set ();
 432                         }
 433                         catch (Exception e) {
 434                                 message = e.ToString ();
 435                         }
 436                 }
 437
 438                 [Test]
 439                 [EnvironmentPermission (SecurityAction.Deny, Read = "USERNAME")]
 440                 [Ignore ("fails when EndGetHostEntry is called")]
 441                 public void AsyncGetHostEntry_IPAddress ()
 442                 {
 443                         message = "AsyncGetHostEntry_IPAddress";
 444                         reset.Reset ();
 445                         IAsyncResult r = Dns.BeginGetHostEntry (ip, new AsyncCallback (GetHostEntryCallback), null);
 446                         Assert.IsNotNull (r, "IAsyncResult");
 447                         // note for some reason r.AsyncWaitHandle.Wait won't work as expected
 448                         // if (!r.AsyncWaitHandle.WaitOne (timeout, true))
 449                         if (!reset.WaitOne (timeout, true))
 450                                 Assert.Ignore ("Timeout");
 451                         Assert.IsNull (message, message);
 452                 }
 453
 454                 [Test]
 455                 [EnvironmentPermission (SecurityAction.Deny, Read = "USERNAME")]
 456                 public void AsyncGetHostEntry_String ()
 457                 {
 458                         message = "AsyncGetHostEntry_String";
 459                         reset.Reset ();
 460                         IAsyncResult r = Dns.BeginGetHostEntry (site, new AsyncCallback (GetHostEntryCallback), null);
 461                         Assert.IsNotNull (r, "IAsyncResult");
 462                         // note for some reason r.AsyncWaitHandle.Wait won't work as expected
 463                         // if (!r.AsyncWaitHandle.WaitOne (timeout, true))
 464                         if (!reset.WaitOne (timeout, true))
 465                                 Assert.Ignore ("Timeout");
 466                         Assert.IsNull (message, message);
 467                 }
 468
 469                 [DnsPermission (SecurityAction.Deny, Unrestricted = true)]
 470                 private void GetHostAddressesCallback (IAsyncResult ar)
 471                 {
 472                         Dns.EndGetHostEntry (ar);
 473                         try {
 474                                 // can we do something bad here ?
 475                                 Assert.IsNotNull (Environment.GetEnvironmentVariable ("USERNAME"));
 476                                 message = "Expected a SecurityException";
 477                         }
 478                         catch (SecurityException) {
 479                                 message = null;
 480                                 reset.Set ();
 481                         }
 482                         catch (Exception e) {
 483                                 message = e.ToString ();
 484                         }
 485                 }
 486
 487                 [Test]
 488                 [EnvironmentPermission (SecurityAction.Deny, Read = "USERNAME")]
 489                 public void AsyncGetHostAddresses ()
 490                 {
 491                         message = "AsyncGetHostAddresses";
 492                         reset.Reset ();
 493                         IAsyncResult r = Dns.BeginGetHostAddresses (site, new AsyncCallback (GetHostAddressesCallback), null);
 494                         Assert.IsNotNull (r, "IAsyncResult");
 495                         // note for some reason r.AsyncWaitHandle.Wait won't work as expected
 496                         // if (!r.AsyncWaitHandle.WaitOne (timeout, true))
 497                         if (!reset.WaitOne (timeout, true))
 498                                 Assert.Ignore ("Timeout");
 499                         Assert.IsNull (message, message);
 500                 }
 501 */
 502 #endif
 503         }
 504 }