/// <summary>
/// SMB file constructor.
/// </summary>
/// <param name="shareType">The type of resource the client intends to access.</param>
/// <param name="name">The name of the file.</param>
/// <param name="treeId">This is used to indicate the share that the client is accessing.</param>
/// <param name="accessRights">Access right.</param>
public SmbFile(ShareType shareType, string name, int treeId, int accessRights)
{
this.shareType = shareType;
this.name = name;
this.treeId = treeId;
this.accessRights = accessRights;
}
public SmbMailslot(ShareType shareType, string pipeName, int treeId)
{
this.shareType = shareType;
this.pipeName = pipeName;
this.treeId = treeId;
this.avaiableDataBytes = 0;
}
public SmbMailslot(ShareType shareType, string pipeName, int treeId, int accessRights, bool isOpened)
{
this.shareType = shareType;
this.pipeName = pipeName;
this.treeId = treeId;
this.accessRights = accessRights;
this.isOpened = isOpened;
this.avaiableDataBytes = 0;
}
public Share(string server, string netName, ShareType shareType)
{
if(ShareType.Special == shareType && "IPC$" == netName)
{
shareType |= ShareType.IPC;
}
_shareServer = server;
_networkName = netName;
_shareType = shareType;
}
public ShareInfo(string serverName, string netName, string path, ShareType shareType, string remark)
{
if (shareType == ShareType.Special && netName == "IPC$")
{
shareType |= ShareType.IPC;
}
_serverName = serverName;
_netName = netName;
_path = path;
_shareType = shareType;
_remark = remark;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="server">The server.</param>
/// <param name="netName">Name of the net.</param>
/// <param name="path">The path.</param>
/// <param name="shareType">Type of the share.</param>
/// <param name="remark">The remark.</param>
public Share(string server, string netName, string path, ShareType shareType, string remark)
{
if (ShareType.Special == shareType && "IPC$" == netName)
{
shareType |= ShareType.IPC;
}
_server = server;
_netName = netName;
_path = path;
_shareType = shareType;
_remark = remark;
}
internal ShareMonitor(string shareName, string hostName, string userName)
{
_share = shareName.Trim();
_host = hostName.Trim();
_user = userName.Trim();
if (_share.Equals(string.Empty))
{
if (_host.Equals(string.Empty))
{
if (_user.Equals(string.Empty))
{
MonitoringType = ShareType.Undefined;
}
else
{
MonitoringType = ShareType.UserOnly;
}
}
else if (_user.Equals(string.Empty))
{
MonitoringType = ShareType.HostOnly;
}
else
{
MonitoringType = ShareType.UserFromHostConnected;
}
}
else if (_host.Equals(string.Empty))
{
if (_user.Equals(string.Empty))
{
MonitoringType = ShareType.ShareOnly;
}
else
{
MonitoringType = ShareType.UserUsingShare;
}
}
else if (_user.Equals(string.Empty))
{
MonitoringType = ShareType.HostUsingShare;
}
else
{
MonitoringType = ShareType.UserFromHostUsingShare;
}
Log.Debug("ShareMonitor: Monitor user '{0}' from host '{1}' on share '{2}' Type '{3}'", _user, _host, _share,
MonitoringType);
}
internal ShareMonitor(string shareName, string clientName, string userName)
{
_share = shareName.Trim();
_client = clientName.Trim();
_user = userName.Trim();
if (_share.Equals(string.Empty))
{
if (_client.Equals(string.Empty))
{
if (_user.Equals(string.Empty))
{
MonitoringType = ShareType.Any;
}
else
{
MonitoringType = ShareType.UserOnly;
}
}
else if (_user.Equals(string.Empty))
{
MonitoringType = ShareType.ClientOnly;
}
else
{
MonitoringType = ShareType.UserFromClientConnected;
}
}
else if (_client.Equals(string.Empty))
{
if (_user.Equals(string.Empty))
{
MonitoringType = ShareType.ShareOnly;
}
else
{
MonitoringType = ShareType.UserUsingShare;
}
}
else if (_user.Equals(string.Empty))
{
MonitoringType = ShareType.ClientUsingShare;
}
else
{
MonitoringType = ShareType.UserFromClientUsingShare;
}
Log.Debug("ActiveSharesHandler: Monitor connections to share '{0}' from client '{1}' by user '{2}' (Type '{3}')", _share, _client, _user, MonitoringType);
}
public override ShareCollection GetUserFavorites(int favOwnerID, ShareType? favType, int pageNumber, int pageSize, ref int? totalCount)
{
using (SqlQuery query = new SqlQuery())
{
query.Pager.TableName = "[bx_SharesView]";
query.Pager.SortField = "[ShareID]";
query.Pager.IsDesc = true;
query.Pager.PageNumber = pageNumber;
query.Pager.PageSize = pageSize;
query.Pager.TotalRecords = totalCount;
query.Pager.SelectCount = true;
SqlConditionBuilder cb = new SqlConditionBuilder(SqlConditionStart.None);
cb.Append("[UserID] = @UserID");
query.CreateParameter<int>("@UserID", favOwnerID, SqlDbType.Int);
if (favType.HasValue && favType.Value != ShareType.All)
{
cb.Append("[Type] = @Type");
query.CreateParameter<ShareType>("@Type", favType.Value, SqlDbType.TinyInt);
}
cb.Append("[PrivacyType] = 2");
query.Pager.Condition = cb.ToString();
using (XSqlDataReader reader = query.ExecuteReader())
{
ShareCollection shares = new ShareCollection(reader);
if (reader.NextResult())
{
if (totalCount == null && reader.Read())
{
totalCount = reader.Get<int>(0);
}
shares.TotalRecords = totalCount.GetValueOrDefault();
}
return shares;
}
}
}
/// <summary>
/// To the type of the network share.
/// </summary>
/// <param name="shareType">Type of the share.</param>
/// <returns>NetworkShareType.</returns>
/// <exception cref="System.ArgumentException">Unknown share type</exception>
private NetworkShareType ToNetworkShareType(ShareType shareType)
{
if (shareType.HasFlag(ShareType.Special))
{
return NetworkShareType.Special;
}
if (shareType.HasFlag(ShareType.Device))
{
return NetworkShareType.Device;
}
if (shareType.HasFlag(ShareType.Disk))
{
return NetworkShareType.Disk;
}
if (shareType.HasFlag(ShareType.IPC))
{
return NetworkShareType.Ipc;
}
if (shareType.HasFlag(ShareType.Printer))
{
return NetworkShareType.Printer;
}
throw new ArgumentException("Unknown share type");
}
/// <summary>
/// Tree connect request.
/// </summary>
/// <param name="messageId">This is used to associate a response with a request.</param>
/// <param name="sessionId">Session id. </param>
/// <param name="isTidDisconnectionSet">Indicate whether the client sets the tid disconnection.</param>
/// <param name="isRequestExtSignature">Indicate whether the client requests extended signature.</param>
/// <param name="isRequestExtResponse">
/// Indicate whether the client requests extended information on Tree connection response.
/// </param>
/// <param name="share">The share method.</param>
/// <param name="shareType">The type of resource the client intends to access.</param>
/// <param name="isSigned" >
/// Indicate whether the SUT has message signing enabled or required.
/// </param>
public void TreeConnectRequest(
int messageId,
int sessionId,
bool isTidDisconnectionSet,
bool isRequestExtSignature,
bool isRequestExtResponse,
string share,
ShareType shareType,
bool isSigned)
{
#region Create Packet
ushort sessionUid = ushort.MinValue;
if (!this.uId.ContainsKey((uint)sessionId))
{
sessionUid = (ushort)sessionId;
}
else
{
sessionUid = (ushort)this.uId[(uint)sessionId];
}
SmbAdapter.ServiceShareType = shareType;
string shareName = string.Empty;
switch (shareType)
{
case ShareType.NamedPipe:
shareName = Site.Properties["SutNamedPipeFullName"];
break;
case ShareType.Printer:
shareName = Site.Properties["SutSharePrinterFullName"];
break;
case ShareType.Disk:
if (SmbAdapter.FsType == FileSystemType.Ntfs.ToString())
{
if (share == ShareName.Share1.ToString())
{
shareName = Site.Properties["SutNtfsShare1FullName"];
}
else
{
if (share == ShareName.Share2.ToString())
{
shareName = Site.Properties["SutNtfsShare2FullName"];
}
else if (share == ShareName.DfsShare.ToString())
{
shareName = Site.Properties["SutShareDfsTreeConnect"];
}
else if (share == ShareName.QuotaShare.ToString())
{
shareName = Site.Properties["SutNtfsQuotaShareFullName"];
}
}
}
else
{
if (share == ShareName.Share1.ToString())
{
shareName = Site.Properties["SutFatShare1FullName"];
}
else
{
if (share == ShareName.Share2.ToString())
{
shareName = Site.Properties["SutFatShare2FullName"];
}
else if (share == ShareName.DfsShare.ToString())
shareName = Site.Properties["SutShareDfsTreeConnect"];
}
}
break;
default:
shareName = string.Empty;
break;
}
SmbTreeConnectAndxRequestPacket smbPacket = new SmbTreeConnectAndxRequestPacket();
// Create TreeConnect Request.
smbPacket = this.smbClientStack.CreateTreeConnectRequest(sessionUid, shareName);
if (isSigned)
{
NamespaceCifs.CifsClientPerConnection connection =
this.smbClientStack.Context.GetConnection(ConnectionId);
NamespaceCifs.CifsClientPerSession session =
this.smbClientStack.Context.GetSession(ConnectionId, sessionUid);
smbPacket.Sign(connection.ClientNextSendSequenceNumber, session.SessionKey);
}
#endregion
#region Send and Receive ExpectPacket
this.smbClientStack.SendPacket(smbPacket);
StackPacket response = this.smbClientStack.ExpectPacket(this.timeout);
NamespaceCifs.SmbPacket smbPacketResponse = (NamespaceCifs.SmbPacket)response;
isSigned = smbPacket.IsSignRequired;
ushort uid = this.QueryUidTable(smbPacketResponse);
ushort tid = this.QueryTidTable(smbPacketResponse);
VerifyTransport(smbPacketResponse);
VerifyCommonMessageSyntax(smbPacketResponse);
if (response.GetType() == typeof(SmbErrorResponsePacket))
{
SmbErrorResponsePacket smbErrorResponsePacket = response as SmbErrorResponsePacket;
NamespaceCifs.SmbHeader smbErrorHeader = smbErrorResponsePacket.SmbHeader;
this.ErrorTreeConnectResponse(
smbErrorHeader.Mid + this.addMidMark,
(MessageStatus)smbErrorHeader.Status,
Boolean.Parse(this.Site.Properties["SHOULDMAYR357Implementation"]));
}
else
{
SmbTreeConnectAndxResponsePacket smbTreeConnectAndXPacket
= response as SmbTreeConnectAndxResponsePacket;
NamespaceCifs.SmbHeader treeConnectAndXResponseHeader = smbTreeConnectAndXPacket.SmbHeader;
SMB_COM_TREE_CONNECT_ANDX_Response_SMB_Parameters treeConnectAndXResponsePayload
= smbTreeConnectAndXPacket.SmbParameters;
NamespaceCifs.SMB_COM_TREE_CONNECT_ANDX_Response_SMB_Data treeConnectAndXResponseData
= smbTreeConnectAndXPacket.SmbData;
ShareType serviceShareType = ShareType.CommunicationDevice;
string shareTypesString = Encoding.ASCII.GetString(treeConnectAndXResponseData.Service);
if (shareTypesString == Disk)
{
serviceShareType = ShareType.Disk;
}
else if (shareTypesString == Printer)
{
serviceShareType = ShareType.Printer;
}
else if (shareTypesString == NamePipe)
{
serviceShareType = ShareType.NamedPipe;
}
else if (shareTypesString == CommunicationsDevice)
{
serviceShareType = ShareType.CommunicationDevice;
}
bool isNotionSupported = Boolean.Parse(Site.Properties["IsNotionSupported"]);
bool isSHI1005Set = Boolean.Parse(Site.Properties["IsShi1005Set"]);
bool isNoAliasingSet = Boolean.Parse(Site.Properties["IsNoAliasingSet"]);
bool isShortFileNameDisabled = Boolean.Parse(Site.Properties["IsShortFileNameDisabled"]);
int allowedGuestAccess = Int32.Parse(Site.Properties["AllowedGuestAccess"]);
// If the Flags contains SMB_FLAGS2_EXTENDED_SECURITY (0x0800),
// means the server supports extended security
if ((smbPacket.SmbParameters.Flags & 0x0800) == 0x0800)
{
VerifyMessageSystaxAccessMasksForPrinter(
smbTreeConnectAndXPacket,
shareType);
}
VerifyMessageSyntaxSmbComTreeConnectResponse(
smbTreeConnectAndXPacket,
isNotionSupported,
isSHI1005Set,
isNoAliasingSet,
isShortFileNameDisabled,
allowedGuestAccess,
((smbPacket.SmbParameters.Flags & 0x0008) == 0x0008));
uint computedMaxRights = (uint)Int32.Parse(Site.Properties["ComputedMaxRights"]);
ushort computedOptionalSupport = (ushort)Int32.Parse(Site.Properties["ComputedOptionalSupport"]);
bool isGuestAccountSupported = Boolean.Parse(Site.Properties["IsGuestAccountSupported"]);
VerifyReceiveSmbComTreeConnectAndXRequest(
smbTreeConnectAndXPacket,
((smbPacket.SmbParameters.Flags & 0x0008) == 0x0008),
computedMaxRights,
computedOptionalSupport,
isGuestAccountSupported,
isRequestExtSignature);
bool isSignSignatureZero = (treeConnectAndXResponseHeader.SecurityFeatures == uint.MinValue);
bool isInDFS = ((treeConnectAndXResponsePayload.OptionalSupport & SmbShareIsInDfs) == SmbShareIsInDfs);
this.TreeConnectResponse(
treeConnectAndXResponseHeader.Mid + this.addMidMark,
uid,
tid,
isSignSignatureZero,
serviceShareType,
(MessageStatus)treeConnectAndXResponseHeader.Status,
isSigned,
isInDFS,
isRequestExtSignature);
}
#endregion
}
/// <summary>
/// Sets value for share_type
/// </summary>
/// <param name="share_type">flag of share type</param>
public void SetShareType( ShareType share_type )
{
switch (share_type) {
case ShareType.Public: {
this.share_type = "P";
break;
}
case ShareType.Tracked: {
this.share_type = "T";
break;
}
case ShareType.Confidential: {
this.share_type = "C";
break;
}
}
}
public void NtTransactCreateRequest(
int messageId,
int sessionId,
int treeId,
[Domain("ImpersonationLevel")] int impersonationLevel,
[Domain("FileDomain")] string fileName,
ShareType shareType,
bool isSigned)
{
#region Create Packet
SmbNtCreateAndxRequestPacket smbPacket = new SmbNtCreateAndxRequestPacket();
ushort uid = (ushort)this.uId[(uint)sessionId];
ushort tid = (ushort)this.tId[(uint)treeId];
string shareName = string.Empty;
if (shareType == ShareType.NamedPipe)
{
if (SmbAdapter.isMessageModePipe)
{
shareName = Site.Properties["SutShareMessagePipe"];
}
else
{
shareName = Site.Properties["SutShareStreamPipe"];
}
}
else
{
if (fileName == Site.Properties["SutShareTest1"])
{
shareName = Site.Properties["SutShareTest1"];
}
else if (fileName == Site.Properties["SutShareTest2"])
{
shareName = Site.Properties["SutShareTest2"];
}
else if (fileName == Site.Properties["SutShareExistFile"])
{
shareName = Site.Properties["SutShareExistFile"];
}
else if (fileName.Contains("."))
{
shareName = fileName;
}
else
{
shareName = fileName;
}
}
this.openedFileName = shareName;
uint nTDesiredAccess = (uint)NamespaceCifs.NtTransactDesiredAccess.GENERIC_ALL;
NamespaceCifs.SMB_EXT_FILE_ATTR extFileAttributes = NamespaceCifs.SMB_EXT_FILE_ATTR.NONE;
NtTransactCreateOptions createOption = NtTransactCreateOptions.FILE_NON_DIRECTORY_FILE;
smbPacket = this.smbClientStack.CreateCreateRequest(
tid,
shareName,
(NamespaceCifs.NtTransactDesiredAccess)nTDesiredAccess,
extFileAttributes,
NamespaceCifs.NtTransactShareAccess.NONE,
NamespaceCifs.NtTransactCreateDisposition.FILE_OPEN_IF,
createOption,
(NamespaceCifs.NtTransactImpersonationLevel)impersonationLevel,
CreateFlags.NT_CREATE_REQUEST_OPLOCK);
if (isSigned)
{
NamespaceCifs.CifsClientPerConnection connection =
this.smbClientStack.Context.GetConnection(ConnectionId);
NamespaceCifs.CifsClientPerSession session = this.smbClientStack.Context.GetSession(ConnectionId, uid);
smbPacket.Sign(connection.ClientNextSendSequenceNumber, session.SessionKey);
}
#endregion
#region Send and Receive ExpectPacket
this.smbClientStack.SendPacket(smbPacket);
StackPacket response = this.smbClientStack.ExpectPacket(this.timeout);
NamespaceCifs.SmbPacket smbPacketResponse = (NamespaceCifs.SmbPacket)response;
this.QueryUidTable(smbPacketResponse);
this.QueryTidTable(smbPacketResponse);
VerifyTransport(smbPacketResponse);
VerifyCommonMessageSyntax(smbPacketResponse);
if (response.GetType() == typeof(SmbErrorResponsePacket))
{
SmbErrorResponsePacket smbErrorResponsePacket = response as SmbErrorResponsePacket;
NamespaceCifs.SmbHeader smbErrorHeader = smbErrorResponsePacket.SmbHeader;
this.ErrorResponse(smbErrorHeader.Mid + this.addMidMark, (MessageStatus)smbErrorHeader.Status);
}
else
{
SmbNtCreateAndxResponsePacket smbNtCreateAndXPacket = response as SmbNtCreateAndxResponsePacket;
NamespaceCifs.SmbHeader ntCreateAndXResponseHeader = smbNtCreateAndXPacket.SmbHeader;
SMB_COM_NT_CREATE_ANDX_Response_SMB_Parameters ntCreateAndXResponsePayload
= smbNtCreateAndXPacket.SmbParameters;
this.smbFileId = ntCreateAndXResponsePayload.FID;
if (!this.fId.ContainsValue(ntCreateAndXResponsePayload.FID))
{
int count = this.fId.Count;
this.fId.Add((uint)(count), ntCreateAndXResponsePayload.FID);
}
else
{
foreach (uint key in this.fId.Keys)
{
if (this.fId[key] == ntCreateAndXResponsePayload.FID)
{
break;
}
}
}
uint creatAction = ntCreateAndXResponsePayload.CreationAction;
Microsoft.Modeling.Set<CreateAction> actionSet = new Microsoft.Modeling.Set<CreateAction>();
if (creatAction == CreateActionSuperseded)
{
actionSet = actionSet.Add(CreateAction.FileSuperseded);
}
if ((creatAction & CreateActionExists) == CreateActionExists)
{
actionSet = actionSet.Add(CreateAction.FileExists);
}
if ((creatAction & CreateActionOpened) == CreateActionOpened)
{
actionSet = actionSet.Add(CreateAction.FileOpened);
if (!actionSet.Contains(CreateAction.FileExists))
{
actionSet = actionSet.Add(CreateAction.FileExists);
}
}
if ((creatAction & CreateActionNotExists) == CreateActionNotExists)
{
actionSet = actionSet.Add(CreateAction.FileDoesNotExist);
}
if ((creatAction & CreateActionCreated) == CreateActionCreated)
{
actionSet = actionSet.Add(CreateAction.FileCreated);
if (!actionSet.Contains(CreateAction.FileDoesNotExist))
{
actionSet = actionSet.Add(CreateAction.FileDoesNotExist);
}
}
if ((creatAction & CreateActionOverwritten) == CreateActionOverwritten)
{
actionSet = actionSet.Add(CreateAction.FileOverwritten);
}
bool isIDZero = false;
bool isVolumnGuidZero = false;
if (!this.checkWindowsImplementation)
{
Site.Log.Add(
LogEntryKind.Comment,
@"isFileIdZero: {0};
isVolumnGUIDZero: {1}",
isIDZero,
isVolumnGuidZero);
isIDZero = true;
isVolumnGuidZero = true;
}
//Workaround temp code (Invalid impersonation level)
if ((string.Equals(Site.Properties["SutPlatformOS"], "Win2K8") && impersonationLevel == 4)
&& !bool.Parse(Site.Properties["IsTDI33006Fixed"]))
{
this.ErrorResponse(ntCreateAndXResponseHeader.Mid + this.addMidMark, MessageStatus.BadImpersonationLevel);
}
else
{
this.NtTransactCreateResponse(
ntCreateAndXResponseHeader.Mid + this.addMidMark,
QueryUidTable(smbPacketResponse),
QueryTidTable(smbPacketResponse),
isSigned,
(MessageStatus)ntCreateAndXResponseHeader.Status);
}
}
#endregion
}
public ShareTypeExtended(ShareType shareType)
{
ShareType = shareType;
IsSpecial = false;
IsTemporary = false;
}
public void Share(string message, string title = "", ShareType shareType = ShareType.Sms)
{
Share(message, shareType);
}
public static IEnumerable <ShareInfo> EnumerateShares(string host, ShareType shareType, bool continueOnException)
{
return(EnumerateSharesCore(host, shareType, continueOnException));
}
//按钮点击分享到微博-截屏的操作可以与微信的合并
public void BtnShareToWeiboOnClick()
{
currentShareType = ShareType.Weibo;
ShowShareHUD();
}
/// <summary> /// 获取好友分享 /// </summary> /// <param name="friendUserIDs">好友用户ID</param> /// <param name="shareType">为null时 表示获取所有类型分享</param> /// <param name="pageNumber"></param> /// <param name="pageSize"></param> /// <param name="totalCount"></param> /// <returns></returns> public abstract ShareCollection GetFriendShares(int userID, ShareType shareType, int pageNumber, int pageSize, out int totalCount);
/// <summary> /// 获取所有用户分享 /// </summary> /// <param name="shareType">为null时 表示获取所有类型分享</param> /// <param name="pageNumber"></param> /// <param name="pageSize"></param> /// <param name="totalCount"></param> /// <returns></returns> public abstract ShareCollection GetAllUserShares(ShareType shareType, int pageNumber, int pageSize, out int totalCount);
///// <summary>
///// 为需要更新的关键字填充恢复关键信息
///// </summary>
///// <param name="processlist">要处理的列表</param>
//public abstract void FillShareReverters(TextRevertable2Collection processlist);
///// <summary>
///// 更新关键字
///// </summary>
///// <param name="processlist">要处理的列表</param>
//public abstract void UpdateShareKeywords(TextRevertable2Collection processlist);
/// <summary>
/// 添加一个分享
/// </summary>
/// <param name="userID"></param>
/// <param name="shareType"></param>
/// <param name="privacyType"></param>
/// <param name="content">简要内容</param>
/// <param name="description">评论</param>
public abstract int CreateShare(int userID, ShareType shareType, PrivacyType privacyType, string title, string url, string content, string description, string descriptionReverter, int targetID);
/// <summary> /// 获取用户分享 /// </summary> /// <param name="userID"></param> /// <param name="shareType">为null时 表示获取所有类型分享</param> /// <param name="privacyType"></param> /// <param name="pageNumber"></param> /// <param name="pageSize"></param> /// <param name="totalCount"></param> /// <returns></returns> public abstract ShareCollection GetUserShares(int userID, ShareType shareType, bool?includeFriendVisiable, int pageNumber, int pageSize, out int totalCount);
public static async Task <IShare> GetAsync(ShareType type)
{
await new WaitUntil(() => !Get(type).IsNull());
return(Get(type));
}
public dynamic GetShareType(String id)
{
ShareType com = stocky.ShareType.Where(e => e.Id == id).FirstOrDefault();
return(new ShareTypeDto(com.Id, com.Type));
}
public Share(ShareType type)
{
Type = type;
}
public static void OpenRequest(
ClientGuidType clientGuidType,
PathNameType pathNameType,
CreateType createType,
ShareType shareType,
AppInstanceIdType appInstanceIdType)
{
Condition.IsTrue(State == ModelState.Connected);
Condition.IsNotNull(Open);
// Isolate below params to limite the expanded test cases.
Combination.Isolated(clientGuidType == ClientGuidType.SameClientGuid);
Combination.Isolated(pathNameType == PathNameType.DifferentPathName);
Combination.Isolated(shareType == ShareType.DifferentShareDifferentLocal);
Combination.Isolated(shareType == ShareType.DifferentShareSameLocal);
Combination.Isolated(appInstanceIdType == AppInstanceIdType.InvalidAppInstanceId);
Combination.Isolated(appInstanceIdType == AppInstanceIdType.NoAppInstanceId);
// "AppInstanceId is zero" is only applicable for the first Create Request.
// For the second Create Request, only valid/notvalid/none make sense.
Condition.IsFalse(appInstanceIdType == AppInstanceIdType.AppInstanceIdIsZero);
// CreateDurableThenDisconnect is only applicable for the first Create Request.
Condition.IsFalse(createType == CreateType.CreateDurableThenDisconnect);
// If the client doesn't disconnect from the server after sending the first Create Request,
// then the second Create Request does not need to contain reconnect context.
// And vice versa.
Condition.IfThen(Open.CreateTypeWhenPrepare != CreateType.CreateDurableThenDisconnect, createType != CreateType.ReconnectDurable);
Condition.IfThen(Open.CreateTypeWhenPrepare == CreateType.CreateDurableThenDisconnect, createType == CreateType.ReconnectDurable);
if (createType == CreateType.ReconnectDurable)
{
ModelHelper.Log(LogType.Requirement,
"3.3.5.9.13: If the create request also includes the SMB2_CREATE_DURABLE_HANDLE_RECONNECT_V2 create context, " +
"the server MUST process the SMB2_CREATE_DURABLE_HANDLE_RECONNECT_V2 create context as specified in section 3.3.5.9.12, " +
"and this section MUST be skipped.");
ModelHelper.Log(LogType.TestInfo, "SMB2_CREATE_DURABLE_HANDLE_RECONNECT_V2 create context is included.");
return;
}
if (!ModelUtility.IsSmb3xFamily(MaxSmbVersionSupported))
{
ModelHelper.Log(LogType.Requirement,
"2.2.13.2.13: The SMB2_CREATE_APP_INSTANCE_ID context is valid only for the SMB 3.x dialect family.");
ModelHelper.Log(LogType.TestInfo, "The dialect version of the server is {0}.", MaxSmbVersionSupported);
return;
}
if (appInstanceIdType == AppInstanceIdType.ValidAppInstanceId && Open.AppInstanceId != AppInstanceIdType.NoAppInstanceId
&& pathNameType == PathNameType.SamePathName
&& shareType == ShareType.SameShare
&& clientGuidType == ClientGuidType.DifferentClientGuid)
{
ModelHelper.Log(LogType.Requirement,
"3.3.5.9.13: The server MUST attempt to locate an Open in GlobalOpenTable where:");
ModelHelper.Log(LogType.Requirement,
"\tAppInstanceId in the request is equal to Open.AppInstanceId.");
ModelHelper.Log(LogType.Requirement,
"\tTarget path name is equal to Open.PathName.");
ModelHelper.Log(LogType.Requirement,
"\tOpen.TreeConnect.Share is equal to TreeConnect.Share.");
ModelHelper.Log(LogType.Requirement,
"\tOpen.Session.Connection.ClientGuid is not equal to the current Connection.ClientGuid.");
ModelHelper.Log(LogType.TestInfo, "All the above conditions are met.");
ModelHelper.Log(LogType.Requirement,
"If an Open is found, the server MUST calculate the maximal access that the user, " +
"identified by Session.SecurityContext, has on the file being opened<277>. " +
"If the maximal access includes GENERIC_READ access, the server MUST close the open as specified in 3.3.4.17.");
// The user used in this model is administrator, so maximal access always includes GENERIC_READ access.
ModelHelper.Log(LogType.TestInfo, "The maximal access includes GENERIC_READ access. So open is closed.");
// close open
Open = null;
}
else
{
ModelHelper.Log(LogType.TestInfo, "appInstanceIdType is {0}.", appInstanceIdType.ToString());
ModelHelper.Log(LogType.TestInfo, "pathNameType is {0}.", pathNameType.ToString());
ModelHelper.Log(LogType.TestInfo, "shareType is {0}.", shareType.ToString());
ModelHelper.Log(LogType.TestInfo, "clientGuidType is {0}.", clientGuidType.ToString());
ModelHelper.Log(LogType.TestInfo, "All the above conditions do not match the requirement, so open will not be closed.");
ModelHelper.Log(LogType.TestTag, TestTag.UnexpectedFields);
}
}
void IWechatSDK.ShareImage(string description, byte[] imageData, ShareType where, UnityAction <string> callback)
{
Register("share_result", callback);
CallMethod(mWechat, "shareImageToWX", description, imageData, (int)where);
}
public static List<ShareInfo> GetShareInfo(ShareType shareType)
{
IList<ShareType> shareTypeList = new List<ShareType>();
shareTypeList.Add(shareType);
return GetShareInfo(Environment.MachineName, shareTypeList);
}
void IWechatSDK.ShareWebpage(string url, string title, string content, ShareType where, UnityAction <string> callback, byte[] thumbData)
{
Register("share_result", callback);
CallMethod(mWechat, "shareWebPageToWX", url, title, content, (int)where, thumbData);
}
protected void Add(string netName, string path, ShareType shareType, string remark)
{
InnerList.Add(new Share(_server, netName, shareType));
}
private void ISmbAdapterInstance_TreeConnectResponse(int messageId, int sessionId, int treeId, bool isSecuritySignatureZero, ShareType shareType, MessageStatus messageStatus, bool isSigned, bool isInDfs, bool isSupportExtSignature)
{
this.Manager.AddEvent(TreeConnectResponseInfo, this.ISmbAdapterInstance, new object[] { messageId, sessionId, treeId, isSecuritySignatureZero, shareType, messageStatus, isSigned, isInDfs, isSupportExtSignature });
}
public ShareTypeExtended(ShareType shareType, bool isSpecial, bool isTemporary)
{
ShareType = shareType;
IsSpecial = isSpecial;
IsTemporary = isTemporary;
}
private void CreateTestFolder(ShareType shareType)
{
new SmbFileSystem().Directory.CreateDirectory(TestHelpers.ShareUri(TestFolder, shareType));
}
/// <summary>
/// Update SMB_COM_TREE_CONNECT_ANDX response.
/// </summary>
/// <param name="connection">It represents the SMB connection.</param>
/// <param name="messageId">This is used to associate a response with a request.</param>
/// <param name="treeId">This is used to indicate the share that the client is accessing.</param>
/// <param name="shareType">The type of resource the client intends to access.</param>
/// <param name="sessionId">
/// Set this value to 0 to request a new session setup, or set this value to a previously established session
/// identifier to request the re-authentication of an existing session.
/// </param>
public static void UpdateTreeConnectResponse(
SmbConnection connection,
int messageId,
int sessionId,
int treeId,
ShareType shareType)
{
TreeConnectRequest request = (TreeConnectRequest)connection.sentRequest[messageId];
connection.treeConnectList.Add(
treeId,
new SmbTree(treeId, new SmbShare(request.shareName, shareType), sessionId));
switch (shareType)
{
case ShareType.Disk:
Parameter.shareFileNames.Remove(request.shareName);
break;
case ShareType.NamedPipe:
Parameter.sharePipeNames.Remove(request.shareName);
break;
case ShareType.Printer:
Parameter.sharePrinterNames.Remove(request.shareName);
break;
case ShareType.CommunicationDevice:
Parameter.shareDeviceNames.Remove(request.shareName);
break;
default:
break;
}
connection.SutSendSequenceNumber.Remove(messageId);
connection.SutSendSequenceNumber.Remove(messageId);
connection.sentRequest.Remove(messageId);
connection.SutNextReceiveSequenceNumber++;
connection.treeId++;
}
private static extern void _cocoCommonShowContentForShareType(ShareType shareType, string imagePath, string title, string content);
/// <summary>
/// Constructor.
/// </summary>
/// <param name="server">Server of the new share.</param>
/// <param name="netName">Name of the new share.</param>
/// <param name="path">Local path of the new share.</param>
/// <param name="shareType">Type of the new share.</param>
/// <param name="remark">Comment of the new share.</param>
public Share(string server, string netName, string path, ShareType shareType, string remark)
{
if (ShareType.Special == shareType && "IPC$" == netName)
shareType |= ShareType.IPC;
if (server.StartsWith("\\\\"))
server = server.Substring(2);
_server = server;
_netName = netName;
_path = path;
_shareType = shareType;
_remark = remark;
}
/// <summary>
/// Write request.
/// </summary>
/// <param name="messageId">This is used to associate a response with a request.</param>
/// <param name="sessionId">The session identifier.</param>
/// <param name="treeId">The tree identifier.</param>
/// <param name="fid">The file identifier.</param>
/// <param name="shareType">The type of share.</param>
/// <param name="isSigned">
/// Indicate whether the SUT has message signing enabled or required.
/// </param>
/// <param name="synchronize">The synchronize method.</param>
public void WriteRequest(
int messageId,
int sessionId,
int treeId,
int fid,
ShareType shareType,
bool isSigned,
int synchronize)
{
#region Create Packet
SmbWriteAndxRequestPacket smbPacket = new SmbWriteAndxRequestPacket();
ushort uid = (ushort)this.uId[(uint)sessionId];
uint offset = uint.Parse(Site.Properties["SmbTransportWriteOffset"]);
ushort fileId = this.smbFileId;
byte[] writeData = Encoding.Unicode.GetBytes(Data);
smbPacket = this.smbClientStack.CreateWriteRequest(fileId, offset, writeData);
if (isSigned)
{
NamespaceCifs.CifsClientPerConnection connection =
this.smbClientStack.Context.GetConnection(ConnectionId);
NamespaceCifs.CifsClientPerSession session = this.smbClientStack.Context.GetSession(ConnectionId, uid);
smbPacket.Sign(connection.ClientNextSendSequenceNumber, session.SessionKey);
}
#endregion
#region Send and Receive ExpectPacket
this.smbClientStack.SendPacket(smbPacket);
StackPacket response = this.smbClientStack.ExpectPacket(this.timeout);
NamespaceCifs.SmbPacket smbPacketResponse = (NamespaceCifs.SmbPacket)response;
this.QueryUidTable(smbPacketResponse);
this.QueryTidTable(smbPacketResponse);
VerifyTransport(smbPacketResponse);
VerifyCommonMessageSyntax(smbPacketResponse);
if (response.GetType() == typeof(SmbErrorResponsePacket))
{
SmbErrorResponsePacket smbErrorResponsePacket = response as SmbErrorResponsePacket;
NamespaceCifs.SmbHeader smbErrorHeader = smbErrorResponsePacket.SmbHeader;
this.ErrorWriteResponse(
smbErrorHeader.Mid + this.addMidMark,
(MessageStatus)smbErrorHeader.Status,
Boolean.Parse(this.Site.Properties["SHOULDMAYR5229Implementation"]));
}
else
{
SmbWriteAndxResponsePacket writeAndxResponsePacket = response as SmbWriteAndxResponsePacket;
VerifyMessageSyntaxSmbComWriteAndXResponse(writeAndxResponsePacket);
if (this.isCopyChunkWrite)
{
this.copyWordCount = writeAndxResponsePacket.SmbParameters.WordCount;
}
else
{
NamespaceCifs.SmbHeader writeAndxResponseHeader = writeAndxResponsePacket.SmbHeader;
this.WriteResponse(
writeAndxResponseHeader.Mid + this.addMidMark,
this.QueryUidTable(smbPacketResponse),
this.QueryTidTable(smbPacketResponse),
(smbPacketResponse).IsSignRequired,
(MessageStatus)writeAndxResponseHeader.Status,
true,
true,
true);
}
}
#endregion
}
public string IsSelected(ShareType type, string result)
{
if (ShareType == type)
return result;
else
return string.Empty;
}
public void OpenRequest(
ClientGuidType clientGuidType,
PathNameType pathNameType,
CreateType createType,
ShareType shareType,
AppInstanceIdType appInstanceIdType)
{
Smb2FunctionalClient testClient = new Smb2FunctionalClient(testConfig.Timeout, testConfig, this.Site);
uint treeId;
string share;
switch (shareType)
{
case ShareType.SameShare:
share = testConfig.BasicFileShare;
break;
case ShareType.DifferentShareSameLocal:
share = testConfig.SameWithSMBBasic;
break;
case ShareType.DifferentShareDifferentLocal:
share = testConfig.DifferentFromSMBBasic;
break;
default:
throw new ArgumentException("shareType");
}
ConnectToShare(
clientDialect,
testClient,
clientGuidType == ClientGuidType.SameClientGuid ? this.connection_ClientGuid : Guid.NewGuid(),
share,
out treeId);
FILEID fileId;
Smb2CreateContextResponse[] createContextResponse;
uint status;
string fileNameInOpen;
if (pathNameType == PathNameType.SamePathName)
{
fileNameInOpen = fileName;
}
else
{
fileNameInOpen = fileName + different;
AddTestFileName(Smb2Utility.GetUncPath(testConfig.SutComputerName, share), fileNameInOpen);
}
status = testClient.Create(
treeId,
fileNameInOpen,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out createContextResponse,
createContexts: CreateContexts(appInstanceIdType, createType, false),
shareAccess: ShareAccess_Values.NONE,
checker: (header, response) => { });
testClient.Disconnect();
testClient = null;
bool ifClosed = CheckIfOpenClosed(clientDialect, createType);
this.OpenResponse(ifClosed ? OpenStatus.OpenClosed : OpenStatus.OpenNotClosed);
}
/// <summary>
/// Read request.
/// </summary>
/// <param name="messageId">This is used to associate a response with a request.</param>
/// <param name="sessionId">The session identifier.</param>
/// <param name="treeId">The tree identifier.</param>
/// <param name="fid">The file identifier.</param>
/// <param name="shareType">The type of share.</param>
/// <param name="isSigned">
/// Indicate whether the SUT has message signing enabled or required.
/// </param>
public void ReadRequest(
int messageId,
int sessionId,
int treeId,
int fid,
ShareType shareType,
bool isSigned)
{
#region Create Packet
SmbReadAndxRequestPacket smbPacket = new SmbReadAndxRequestPacket();
ushort fileId = this.smbFileId;
ushort uid = (ushort)this.uId[(uint)sessionId];
uint offset = (uint)uint.Parse(Site.Properties["SmbTransportReadOffset"]);
ushort maxCount = (ushort)ushort.Parse(Site.Properties["SmbTransportMaxReadDataCount"]);
smbPacket = this.smbClientStack.CreateReadRequest(fileId, maxCount, offset);
if (isSigned)
{
NamespaceCifs.CifsClientPerConnection connection =
this.smbClientStack.Context.GetConnection(ConnectionId);
NamespaceCifs.CifsClientPerSession session = this.smbClientStack.Context.GetSession(ConnectionId, uid);
smbPacket.Sign(connection.ClientNextSendSequenceNumber, session.SessionKey);
}
#endregion
#region Send and Receive ExpectPacket
this.smbClientStack.SendPacket(smbPacket);
StackPacket response = this.smbClientStack.ExpectPacket(this.timeout);
NamespaceCifs.SmbPacket smbPacketResponse = (NamespaceCifs.SmbPacket)response;
this.QueryUidTable(smbPacketResponse);
this.QueryTidTable(smbPacketResponse);
VerifyTransport(smbPacketResponse);
VerifyCommonMessageSyntax(smbPacketResponse);
if (response.GetType() == typeof(SmbErrorResponsePacket))
{
SmbErrorResponsePacket smbErrorResponsePacket = response as SmbErrorResponsePacket;
NamespaceCifs.SmbHeader smbErrorHeader = smbErrorResponsePacket.SmbHeader;
this.ErrorResponse(smbErrorHeader.Mid + this.addMidMark, (MessageStatus)smbErrorHeader.Status);
}
else
{
SmbReadAndxResponsePacket readAndxResponsePacket = response as SmbReadAndxResponsePacket;
NamespaceCifs.SmbHeader readAndxResponseHeader = readAndxResponsePacket.SmbHeader;
int minNumberOfBytesToReturn = int.Parse(Site.Properties["MinNumberOfBytesToReturn"]);
bool isReadOnPipe = false;
bool isReadOnFile = false;
if (shareType == ShareType.NamedPipe)
{
isReadOnPipe = true;
}
else if (shareType == ShareType.Disk)
{
isReadOnFile = true;
}
VerifyReceiveSmbComReadAndXRequest(
readAndxResponsePacket,
minNumberOfBytesToReturn,
isReadOnPipe,
isReadOnFile);
this.ReadResponse(
readAndxResponseHeader.Mid + this.addMidMark,
this.QueryUidTable(smbPacketResponse),
this.QueryTidTable(smbPacketResponse),
(smbPacketResponse).IsSignRequired,
true,
(MessageStatus)readAndxResponseHeader.Status);
}
#endregion
}
/// <summary>
/// Verify Access Masks.
/// </summary>
/// <param name="smbTreeConnectAndxPacket">Packets for SmbTreeConnectAndxPacket Response.</param>
/// <param name="shareType">To judge if the share type is the Printer</param>
private void VerifyMessageSystaxAccessMasksForPrinter(
SmbTreeConnectAndxResponsePacket smbTreeConnectAndxPacket,
ShareType shareType)
{
if (shareType == ShareType.Printer)
{
//
// The following statement code will be run only when debugging.
//
Site.Log.Add(LogEntryKind.Debug,
@"Verify MS-SMB_R109080");
//
// Verify MS-SMB requirement: MS-SMB_R109080.
//
bool isContainFILE_WRITE_DATA = (smbTreeConnectAndxPacket.SmbParameters.MaximalShareAccessRights &
(uint)CIFS.NtTransactDesiredAccess.FILE_WRITE_DATA) == (uint)CIFS.NtTransactDesiredAccess.FILE_WRITE_DATA;
bool isContainFile_APPEND_DATA = (smbTreeConnectAndxPacket.SmbParameters.MaximalShareAccessRights &
(uint)CIFS.NtTransactDesiredAccess.FILE_APPEND_DATA) == (uint)CIFS.NtTransactDesiredAccess.FILE_APPEND_DATA;
bool isContainGENERIC_WRITE = (smbTreeConnectAndxPacket.SmbParameters.MaximalShareAccessRights &
(uint)CIFS.NtTransactDesiredAccess.GENERIC_WRITE) == (uint)CIFS.NtTransactDesiredAccess.GENERIC_WRITE;
bool isContainValue = isContainFILE_WRITE_DATA || isContainFile_APPEND_DATA || isContainGENERIC_WRITE;
// If the value has at least one of the following: FILE_WRITE_DATA, FILE_APPEND_DATA, or GENERIC_WRITE,
// then the isContainValue equals true, this requirement is captured.
Site.CaptureRequirementIfIsTrue(
isContainValue,
109080,
"[In File_Pipe_Printer_Access_Mask]File_Pipe_Printer_Access_Mask (4 bytes): For a printer, the value MUST have at least one of the following: FILE_WRITE_DATA, FILE_APPEND_DATA, or GENERIC_WRITE.");
}
}
/// <summary>
/// Tree multiple connect request
/// </summary>
/// <param name="messageId">This is used to associate a response with a request.</param>
/// <param name="sessionId">The current session ID for this connection.</param>
/// <param name="isTidDisconnectionSet">Indicate whether the client sets the tid disconnection.</param>
/// <param name="isRequestExtSignature">Indicate whether the client requests the extended signature.</param>
/// <param name="isRequestExtResponse">
/// Indicate whether the client requests the extended information on Tree connection response.
/// </param>
/// <param name="share">The share method.</param>
/// <param name="shareType">The share type client intends to access.</param>
/// <param name="isSigned">Indicate whether the message is signed or not for this request.</param>
public void TreeMultipleConnectRequest(
int messageId,
int sessionId,
bool isTidDisconnectionSet,
bool isRequestExtSignature,
bool isRequestExtResponse,
string share,
ShareType shareType,
bool isSigned)
{
#region Create Packet
ushort sessionUid = ushort.MinValue;
if (!this.uId.ContainsKey((uint)sessionId))
{
sessionUid = (ushort)sessionId;
}
else
{
sessionUid = (ushort)this.uId[(uint)sessionId];
}
SmbAdapter.ServiceShareType = shareType;
string shareName = string.Empty;
switch (shareType)
{
case ShareType.NamedPipe:
shareName = Site.Properties["SutNamedPipeFullName"];
break;
case ShareType.Printer:
shareName = Site.Properties["SutSharePrinterFullName"];
break;
case ShareType.Disk:
if (SmbAdapter.FsType == FileSystemType.Ntfs.ToString())
{
if (share == ShareName.Share1.ToString())
{
shareName = Site.Properties["SutNtfsShare1FullName"];
}
else
{
if (share == ShareName.Share2.ToString())
{
shareName = Site.Properties["SutNtfsShare2FullName"];
}
else if (share == ShareName.DfsShare.ToString())
{
shareName = Site.Properties["SutShareDfsTreeConnect"];
}
}
}
else
{
if (share == ShareName.Share1.ToString())
{
shareName = Site.Properties["SutFatShare1FullName"];
}
else
{
if (share == ShareName.Share2.ToString())
{
shareName = Site.Properties["SutFatShare2FullName"];
}
else if (share == ShareName.DfsShare.ToString())
shareName = Site.Properties["SutShareDfsTreeConnect"];
}
}
break;
default:
shareName = string.Empty;
break;
}
SmbTreeConnectAndxRequestPacket smbPacket = new SmbTreeConnectAndxRequestPacket();
// Create TreeConnect Request.
smbPacket = this.smbClientStack.CreateTreeConnectRequest(sessionUid, shareName);
if (isSigned)
{
NamespaceCifs.CifsClientPerConnection connection =
this.smbClientStack.Context.GetConnection(ConnectionId);
NamespaceCifs.CifsClientPerSession session =
this.smbClientStack.Context.GetSession(ConnectionId, sessionUid);
smbPacket.Sign(connection.ClientNextSendSequenceNumber, session.SessionKey);
}
#endregion
#region Send and Receive ExpectPacket
this.smbClientStack.SendPacket(smbPacket);
StackPacket response = this.smbClientStack.ExpectPacket(this.timeout);
NamespaceCifs.SmbPacket smbPacketResponse = (NamespaceCifs.SmbPacket)response;
isSigned = smbPacket.IsSignRequired;
ushort uid = this.QueryUidTable(smbPacketResponse);
ushort tid = this.QueryTidTable(smbPacketResponse);
VerifyTransport(smbPacketResponse);
VerifyCommonMessageSyntax(smbPacketResponse);
if (response.GetType() == typeof(SmbErrorResponsePacket))
{
SmbErrorResponsePacket smbErrorResponsePacket = response as SmbErrorResponsePacket;
NamespaceCifs.SmbHeader smbErrorHeader = smbErrorResponsePacket.SmbHeader;
this.ErrorTreeConnectResponse(
smbErrorHeader.Mid + this.addMidMark,
(MessageStatus)smbErrorHeader.Status,
Boolean.Parse(this.Site.Properties["SHOULDMAYR357Implementation"]));
}
else
{
SmbTreeConnectAndxResponsePacket smbTreeConnectAndXPacket
= response as SmbTreeConnectAndxResponsePacket;
NamespaceCifs.SmbHeader treeConnectAndXResponseHeader = smbTreeConnectAndXPacket.SmbHeader;
SMB_COM_TREE_CONNECT_ANDX_Response_SMB_Parameters treeConnectAndXResponsePayload
= smbTreeConnectAndXPacket.SmbParameters;
NamespaceCifs.SMB_COM_TREE_CONNECT_ANDX_Response_SMB_Data treeConnectAndXResponseData
= smbTreeConnectAndXPacket.SmbData;
ShareType serviceShareType = ShareType.CommunicationDevice;
string shareTypesString = Encoding.ASCII.GetString(treeConnectAndXResponseData.Service);
if (shareTypesString == Disk)
{
serviceShareType = ShareType.Disk;
}
else if (shareTypesString == Printer)
{
serviceShareType = ShareType.Printer;
}
else if (shareTypesString == NamePipe)
{
serviceShareType = ShareType.NamedPipe;
}
else if (shareTypesString == CommunicationsDevice)
{
serviceShareType = ShareType.CommunicationDevice;
}
bool isSignSignatureZero = (treeConnectAndXResponseHeader.SecurityFeatures == uint.MinValue);
bool isInDFS = ((treeConnectAndXResponsePayload.OptionalSupport & SmbShareIsInDfs) == SmbShareIsInDfs);
this.TreeConnectResponse(
treeConnectAndXResponseHeader.Mid + this.addMidMark,
uid,
tid,
isSignSignatureZero,
serviceShareType,
(MessageStatus)treeConnectAndXResponseHeader.Status,
isSigned,
isInDFS,
isRequestExtSignature);
}
#endregion
}
public static IEnumerable <ShareInfo> EnumerateShares(ShareType shareType, bool continueOnException)
{
return(EnumerateSharesCore(null, shareType, continueOnException));
}
public void CreateRequest(
int messageId,
int sessionId,
int treeId,
int desiredAccess,
CreateDisposition createDisposition,
[Domain("ImpersonationLevel")] int impersonationLevel,
string fileName,
ShareType shareType,
bool isSigned,
bool isOpenByFileId,
bool isDirectoryFile,
bool isMaximumAllowedSet)
{
#region Create Packet
SmbNtCreateAndxRequestPacket smbPacket = new SmbNtCreateAndxRequestPacket();
ushort uid = (ushort)this.uId[(uint)sessionId];
ushort tid = (ushort)this.tId[(uint)treeId];
string shareName = string.Empty;
CreateFlags createFlags;
bool isCreateDirectory = false;
if (fileName != Site.Properties["SutShareExistFile"].ToString())
{
if (createDisposition == CreateDisposition.FileOpenIf)
{
this.createActionInternal = this.createActionInternal.Add(CreateAction.FileCreated);
this.createActionInternal = this.createActionInternal.Add(CreateAction.FileDoesNotExist);
}
}
if (shareType == ShareType.NamedPipe)
{
if (SmbAdapter.isMessageModePipe)
{
shareName = Site.Properties["SutShareMessagePipe"];
}
else
{
shareName = Site.Properties["SutShareStreamPipe"];
}
isCreateDirectory = false;
}
else
{
if (fileName == Site.Properties["SutShareTest1"])
{
shareName = Site.Properties["SutShareTest1"];
isCreateDirectory = false;
}
else if (fileName == Site.Properties["SutShareTest2"])
{
shareName = Site.Properties["SutShareTest2"];
isCreateDirectory = false;
}
else if (fileName == Site.Properties["SutShareExistFile"])
{
shareName = Site.Properties["SutShareExistFile"];
isCreateDirectory = false;
}
else if (fileName.Contains("."))
{
shareName = fileName;
isCreateDirectory = false;
}
else
{
shareName = fileName;
isCreateDirectory = true;
}
}
this.openedFileName = shareName;
if (isCreateDirectory)
{
createFlags = CreateFlags.NT_CREATE_OPEN_TARGET_DIR | CreateFlags.NT_CREATE_REQUEST_EXTENDED_RESPONSE;
}
else
{
createFlags = CreateFlags.NT_CREATE_REQUEST_EXTENDED_RESPONSE;
}
NamespaceCifs.NtTransactShareAccess shareAccess =
(NamespaceCifs.NtTransactShareAccess)ushort.Parse(Site.Properties["SmbTransportShareAccess"]);
NamespaceCifs.SMB_EXT_FILE_ATTR extFileAttributes = NamespaceCifs.SMB_EXT_FILE_ATTR.NONE;
NamespaceCifs.NtTransactCreateDisposition ntCreateDisposition =
(NamespaceCifs.NtTransactCreateDisposition)createDisposition;
NtTransactCreateOptions createOption = NtTransactCreateOptions.FILE_DIRECTORY_FILE;
if (isOpenByFileId && isDirectoryFile)
{
createOption =
NtTransactCreateOptions.FILE_OPEN_BY_FILE_ID | NtTransactCreateOptions.FILE_DIRECTORY_FILE;
}
if (isOpenByFileId && !isDirectoryFile)
{
createOption =
NtTransactCreateOptions.FILE_NON_DIRECTORY_FILE | NtTransactCreateOptions.FILE_OPEN_BY_FILE_ID;
}
if (!isOpenByFileId && isDirectoryFile)
{
createOption = NtTransactCreateOptions.FILE_DIRECTORY_FILE;
}
if (!isOpenByFileId && !isDirectoryFile)
{
createOption = NtTransactCreateOptions.FILE_NON_DIRECTORY_FILE;
}
NamespaceCifs.NtTransactDesiredAccess nTDesiredAccess =
(NamespaceCifs.NtTransactDesiredAccess)desiredAccess;
if (nTDesiredAccess == (
NamespaceCifs.NtTransactDesiredAccess.FILE_READ_DATA
| NamespaceCifs.NtTransactDesiredAccess.FILE_WRITE_DATA))
{
nTDesiredAccess = NamespaceCifs.NtTransactDesiredAccess.GENERIC_ALL;
}
if (isCreateDirectory)
{
nTDesiredAccess = Microsoft.Protocols.TestTools.StackSdk.FileAccessService.Cifs.NtTransactDesiredAccess.FILE_READ_DATA |
Microsoft.Protocols.TestTools.StackSdk.FileAccessService.Cifs.NtTransactDesiredAccess.FILE_READ_ATTRIBUTES |
Microsoft.Protocols.TestTools.StackSdk.FileAccessService.Cifs.NtTransactDesiredAccess.SYNCHRONIZE;
shareAccess = NamespaceCifs.NtTransactShareAccess.FILE_SHARE_READ | NamespaceCifs.NtTransactShareAccess.FILE_SHARE_WRITE;
}
smbPacket = this.smbClientStack.CreateCreateRequest(
tid,
shareName,
nTDesiredAccess,
extFileAttributes,
shareAccess,
ntCreateDisposition,
createOption,
(NamespaceCifs.NtTransactImpersonationLevel)impersonationLevel,
createFlags);
if (isSigned)
{
NamespaceCifs.CifsClientPerConnection connection =
this.smbClientStack.Context.GetConnection(ConnectionId);
NamespaceCifs.CifsClientPerSession session =
this.smbClientStack.Context.GetSession(ConnectionId, uid);
smbPacket.Sign(connection.ClientNextSendSequenceNumber, session.SessionKey);
}
#endregion
#region Send and Receive ExpectPacket
this.smbClientStack.SendPacket(smbPacket);
StackPacket response = this.smbClientStack.ExpectPacket(this.timeout);
NamespaceCifs.SmbPacket smbPacketResponse = (NamespaceCifs.SmbPacket)response;
this.QueryUidTable(smbPacketResponse);
this.QueryTidTable(smbPacketResponse);
VerifyTransport(smbPacketResponse);
VerifyCommonMessageSyntax(smbPacketResponse);
if (response.GetType() == typeof(SmbErrorResponsePacket))
{
SmbErrorResponsePacket smbErrorResponsePacket = response as SmbErrorResponsePacket;
NamespaceCifs.SmbHeader smbErrorHeader = smbErrorResponsePacket.SmbHeader;
this.ErrorResponse(smbErrorHeader.Mid + this.addMidMark, (MessageStatus)smbErrorHeader.Status);
}
else
{
SmbNtCreateAndxResponsePacket smbNtCreateAndXPacket = response as SmbNtCreateAndxResponsePacket;
NamespaceCifs.SmbHeader ntCreateAndXResponseHeader = smbNtCreateAndXPacket.SmbHeader;
SMB_COM_NT_CREATE_ANDX_Response_SMB_Parameters ntCreateAndXResponsePayload =
smbNtCreateAndXPacket.SmbParameters;
this.smbFileId = ntCreateAndXResponsePayload.FID;
int fidValue = (int)uint.MinValue;
if (!this.fId.ContainsValue(ntCreateAndXResponsePayload.FID))
{
int count = this.fId.Count;
this.fId.Add((uint)(count), ntCreateAndXResponsePayload.FID);
fidValue = count;
}
else
{
foreach (uint key in this.fId.Keys)
{
if (this.fId[key] == ntCreateAndXResponsePayload.FID)
{
fidValue = (int)key;
break;
}
}
}
uint creatAction = ntCreateAndXResponsePayload.CreationAction;
Microsoft.Modeling.Set<CreateAction> actionSet = new Microsoft.Modeling.Set<CreateAction>();
if (creatAction == CreateActionSuperseded)
{
actionSet = actionSet.Add(CreateAction.FileSuperseded);
}
if ((creatAction & CreateActionExists) == CreateActionExists)
{
actionSet = actionSet.Add(CreateAction.FileExists);
}
if ((creatAction & CreateActionOpened) == CreateActionOpened)
{
actionSet = actionSet.Add(CreateAction.FileOpened);
if (!actionSet.Contains(CreateAction.FileExists))
{
actionSet = actionSet.Add(CreateAction.FileExists);
}
}
if ((creatAction & CreateActionNotExists) == CreateActionNotExists)
{
actionSet = actionSet.Add(CreateAction.FileDoesNotExist);
}
if ((creatAction & CreateActionCreated) == CreateActionCreated)
{
actionSet = actionSet.Add(CreateAction.FileCreated);
if (!actionSet.Contains(CreateAction.FileDoesNotExist))
{
actionSet = actionSet.Add(CreateAction.FileDoesNotExist);
}
}
if ((creatAction & CreateActionOverwritten) == CreateActionOverwritten)
{
actionSet = actionSet.Add(CreateAction.FileOverwritten);
}
bool isIdZero = false;
bool isNoSubStreams = false;
if (ntCreateAndXResponsePayload.ResourceType == NamespaceCifs.FileTypeValue.FileTypeDisk)
{
if (SmbAdapter.FsType == FileSystemType.Ntfs.ToString())
{
isNoSubStreams = false;
}
else
{
isNoSubStreams = true;
}
}
if (SmbAdapter.ServiceShareType == ShareType.NamedPipe)
{
isNoSubStreams = true;
}
bool isVolumnGuidZero = false;
if (!this.checkWindowsImplementation)
{
Site.Log.Add(
LogEntryKind.Comment,
@"isFileIdZero: {0};
isVolumnGUIDZero: {1}",
isIdZero,
isVolumnGuidZero);
isIdZero = true;
isVolumnGuidZero = true;
}
bool isNotionSupportedForCreate = Boolean.Parse(Site.Properties["IsNotionSupportedForCreate"]);
bool isSerWantCliLeverageNewCap = Boolean.Parse(Site.Properties["IsSerWantCliLeverageNewCap"]);
VerifyMessageSyntaxSmbComNtCreateAndXResponse(
smbNtCreateAndXPacket,
isSerWantCliLeverageNewCap);
VerifyMessageSyntaxSmbComNtCreateAndXResponseForNotNotionSupported(
smbNtCreateAndXPacket,
isNotionSupportedForCreate);
VerifyMessageSyntaxFileIdGeneration(smbNtCreateAndXPacket.SmbParameters.FileId);
VerifyMessageSyntaxVolumeGUIDGeneration(smbNtCreateAndXPacket.SmbParameters.VolumeGUID);
if (0x00000003 >= (uint)impersonationLevel)
{
VerifyMessageSyntaxNtTransactCreateRequest(impersonationLevel);
}
VerifyMessageSyntaxAccessMasks(smbNtCreateAndXPacket, isDirectoryFile);
uint computedMaximalAccessRights = (uint)Int32.Parse(Site.Properties["ComputedMaximalAccessRights"]);
uint computedGuestMaximalAccessRights =
(uint)Int32.Parse(Site.Properties["ComputedGuestMaximalAccessRights"]);
VerifyReceiveSmbComNtCreateAndXRequest(
(uint)smbPacket.SmbHeader.Flags,
smbNtCreateAndXPacket,
computedMaximalAccessRights,
computedGuestMaximalAccessRights,
impersonationLevel == (int)NamespaceCifs.NtTransactImpersonationLevel.SEC_ANONYMOUS ? true : false);
//Workaround temp code (Invalid impersonation level)
if ((string.Equals(Site.Properties["SutPlatformOS"], "Win2K8") && impersonationLevel == 4) &&
!bool.Parse(Site.Properties["IsTDI33006Fixed"]))
{
this.ErrorResponse(ntCreateAndXResponseHeader.Mid + this.addMidMark, MessageStatus.BadImpersonationLevel);
}
else
{
if (this.createActionInternal.Count == uint.MinValue)
{
this.CreateResponse(
ntCreateAndXResponseHeader.Mid + this.addMidMark,
this.QueryUidTable(smbPacketResponse),
this.QueryTidTable(smbPacketResponse),
fidValue,
smbPacketResponse.IsSignRequired,
actionSet,
isIdZero,
isVolumnGuidZero,
(ntCreateAndXResponsePayload.Directory == uint.MinValue),
true,
isNoSubStreams,
(MessageStatus)ntCreateAndXResponseHeader.Status);
}
else
{
this.CreateResponse(
ntCreateAndXResponseHeader.Mid + this.addMidMark,
this.QueryUidTable(smbPacketResponse),
this.QueryTidTable(smbPacketResponse),
fidValue,
(smbPacketResponse).IsSignRequired,
this.createActionInternal,
isIdZero,
isVolumnGuidZero,
(ntCreateAndXResponsePayload.Directory == 0),
true,
isNoSubStreams,
(MessageStatus)ntCreateAndXResponseHeader.Status);
}
}
this.createActionInternal = new Microsoft.Modeling.Set<CreateAction>();
}
#endregion
}
protected void SaveOrUpdateContact(object sender, CommandEventArgs e)
{
try
{
var dao = DaoFactory;
Contact contact;
List <Contact> contactsForSetManager = new List <Contact>();
var typeAddedContact = Request["typeAddedContact"];
#region Rights part #1
ShareType shareType = ShareType.None;// 0 - NotShared, 1 - ReadWriting, 2 - Reading
if (!String.IsNullOrEmpty(Request["isPublicContact"]))
{
try
{
shareType = (ShareType)(Convert.ToInt32(Request["isPublicContact"]));
}
catch (Exception)
{
throw new ArgumentException();
}
}
#endregion
#region BaseInfo
var companyID = 0;
if (!String.IsNullOrEmpty(Request["baseInfo_compID"]))
{
companyID = Convert.ToInt32(Request["baseInfo_compID"]);
}
else if (!String.IsNullOrEmpty(Request["baseInfo_compName"]))
{
var peopleCompany = new Company
{
CompanyName = Request["baseInfo_compName"].Trim(),
ShareType = shareType
};
peopleCompany.ID = dao.ContactDao.SaveContact(peopleCompany);
companyID = peopleCompany.ID;
contactsForSetManager.Add(peopleCompany);
}
if (typeAddedContact.Equals("people"))
{
contact = new Person
{
FirstName = Request["baseInfo_firstName"].Trim(),
LastName = Request["baseInfo_lastName"].Trim(),
JobTitle = Request["baseInfo_personPosition"].Trim(),
CompanyID = companyID
};
}
else
{
contact = new Company
{
CompanyName = Request["baseInfo_companyName"].Trim()
};
}
contact.About = !String.IsNullOrEmpty(Request["baseInfo_contactOverview"]) ? Request["baseInfo_contactOverview"].Trim() : null;
contact.ShareType = shareType;
#endregion
#region ContactType and Currency
contact.ContactTypeID = Convert.ToInt32(Request["baseInfo_contactType"]);
if (contact.ContactTypeID != 0)
{
var listItem = dao.ListItemDao.GetByID(contact.ContactTypeID);
if (listItem == null)
{
throw new Exception(CRMErrorsResource.ContactTypeNotFound);
}
}
contact.Currency = Convert.ToString(Request["baseInfo_currency"]);
if (!String.IsNullOrEmpty(contact.Currency))
{
var currency = CurrencyProvider.Get(contact.Currency);
if (currency == null)
{
throw new Exception(CRMErrorsResource.CurrencyNotFound);
}
}
#endregion
#region Base Operation Of Save/Update
if (TargetContact != null)
{
contact.ID = TargetContact.ID;
contact.StatusID = TargetContact.StatusID;
dao.ContactDao.UpdateContact(contact);
var messageAction = contact is Company ? MessageAction.CompanyUpdated : MessageAction.PersonUpdated;
MessageService.Send(HttpContext.Current.Request, messageAction, MessageTarget.Create(contact.ID), contact.GetTitle());
contact = dao.ContactDao.GetByID(contact.ID);
}
else
{
contact.ID = dao.ContactDao.SaveContact(contact);
var messageAction = contact is Company ? MessageAction.CompanyCreated : MessageAction.PersonCreated;
MessageService.Send(HttpContext.Current.Request, messageAction, MessageTarget.Create(contact.ID), contact.GetTitle());
contact = dao.ContactDao.GetByID(contact.ID);
}
contactsForSetManager.Add(contact);
#endregion
#region persons for company
if (contact is Company)
{
var assignedContactsIDs = new List <int>();
if (!String.IsNullOrEmpty(Request["baseInfo_assignedNewContactsIDs"]))
{
try
{
var assignedContactsObjs = JArray.Parse(Request["baseInfo_assignedNewContactsIDs"]);
var newAssignedContacts = new List <Contact>();
var recordIndex = 0;
foreach (var assignedContactsObj in assignedContactsObjs)
{
newAssignedContacts.Add(new Person
{
ID = recordIndex,
ShareType = shareType,
CompanyID = contact.ID,
FirstName = assignedContactsObj.Value <String>("FirstName"),
LastName = assignedContactsObj.Value <String>("LastName")
});
recordIndex++;
}
dao.ContactDao.SaveContactList(newAssignedContacts);
if (newAssignedContacts.Count != 0)
{
contactsForSetManager.AddRange(newAssignedContacts);
assignedContactsIDs.AddRange(newAssignedContacts.Select(c => c.ID).ToList());
}
}
catch (Exception ex)
{
LogManager.GetLogger("ASC.CRM").Error(ex);
}
}
if (!String.IsNullOrEmpty(Request["baseInfo_assignedContactsIDs"]))
{
assignedContactsIDs.AddRange(Request["baseInfo_assignedContactsIDs"].Split(',').Select(item => Convert.ToInt32(item)).ToList());
}
if (TargetContact != null && !CRMSecurity.IsAdmin)
{
var restrictedMembers = dao.ContactDao.GetRestrictedMembers(contact.ID);
assignedContactsIDs.AddRange(restrictedMembers.Select(m => m.ID).ToList());
}
dao.ContactDao.SetMembers(contact.ID, assignedContactsIDs.ToArray());
}
#endregion
#region tags
var assignedTags = Request["baseInfo_assignedTags"];
if (assignedTags != null)
{
var oldTagList = dao.TagDao.GetEntityTags(EntityType.Contact, contact.ID);
foreach (var tag in oldTagList)
{
dao.TagDao.DeleteTagFromEntity(EntityType.Contact, contact.ID, tag);
}
if (assignedTags != string.Empty)
{
var tagListInfo = JObject.Parse(assignedTags)["tagListInfo"].ToArray();
var newTagList = tagListInfo.Select(t => t.ToString()).ToArray();
dao.TagDao.SetTagToEntity(EntityType.Contact, contact.ID, newTagList);
}
}
#endregion
#region contact infos (addresses, mailes, phones etc.)
var contactInfos = new List <ContactInfo>();
var addressList = new Dictionary <int, ContactInfo>();
var addressTemplate = new JObject();
foreach (String addressPartName in Enum.GetNames(typeof(AddressPart)))
{
addressTemplate.Add(addressPartName.ToLower(), "");
}
var addressTemplateStr = addressTemplate.ToString();
foreach (var item in Request.Form.AllKeys)
{
if (item.StartsWith("customField_"))
{
int fieldID = Convert.ToInt32(item.Split('_')[1]);
String fieldValue = Request.Form[item].Trim();
if (contact is Person)
{
if (!String.IsNullOrEmpty(fieldValue))
{
dao.CustomFieldDao.SetFieldValue(EntityType.Person, contact.ID, fieldID, "");
}
dao.CustomFieldDao.SetFieldValue(EntityType.Person, contact.ID, fieldID, fieldValue);
}
else
{
if (!String.IsNullOrEmpty(fieldValue))
{
dao.CustomFieldDao.SetFieldValue(EntityType.Company, contact.ID, fieldID, "");
}
dao.CustomFieldDao.SetFieldValue(EntityType.Company, contact.ID, fieldID, fieldValue);
}
}
else if (item.StartsWith("contactInfo_"))
{
var nameParts = item.Split('_').Skip(1).ToList();
var contactInfoType = (ContactInfoType)Enum.Parse(typeof(ContactInfoType), nameParts[0]);
var category = Convert.ToInt32(nameParts[2]);
if (contactInfoType == ContactInfoType.Address)
{
var index = Convert.ToInt32(nameParts[1]);
var addressPart = (AddressPart)Enum.Parse(typeof(AddressPart), nameParts[3]);
var isPrimaryAddress = Convert.ToInt32(nameParts[4]) == 1;
var dataValues = Request.Form.GetValues(item).Select(n => n.Trim()).ToList();
if (!addressList.ContainsKey(index))
{
var newAddress = new ContactInfo
{
Category = category,
InfoType = contactInfoType,
Data = addressTemplateStr,
IsPrimary = isPrimaryAddress,
ContactID = contact.ID
};
addressList.Add(index, newAddress);
}
foreach (var data in dataValues)
{
var addressParts = JObject.Parse(addressList[index].Data);
addressParts[addressPart.ToString().ToLower()] = data;
addressList[index].Data = addressParts.ToString();
}
continue;
}
var isPrimary = Convert.ToInt32(nameParts[3]) == 1;
if (Request.Form.GetValues(item) != null)
{
var dataValues = Request.Form.GetValues(item).Where(n => !string.IsNullOrEmpty(n.Trim())).ToList();
contactInfos.AddRange(dataValues.Select(dataValue => new ContactInfo
{
Category = category,
InfoType = contactInfoType,
Data = dataValue.Trim(),
IsPrimary = isPrimary,
ContactID = contact.ID
}));
}
}
}
if (addressList.Count > 0)
{
contactInfos.AddRange(addressList.Values.ToList());
}
dao.ContactInfoDao.DeleteByContact(contact.ID);
dao.ContactInfoDao.SaveList(contactInfos, contact);
#endregion
#region Photo
var imagePath = Request["uploadPhotoPath"];
if (!String.IsNullOrEmpty(imagePath))
{
if (imagePath != "null")
{
ContactPhotoManager.TryUploadPhotoFromTmp(contact.ID, TargetContact == null, TargetContact == null ? imagePath : "");
}
}
else if (TargetContact != null)
{
ContactPhotoManager.DeletePhoto(TargetContact.ID);
}
#endregion
#region Rights part #2
SetContactManager(contactsForSetManager);
#endregion
#region Link with mail message
int result;
var linkMessageId = int.TryParse(Request["linkMessageId"], out result) ? result : 0;
if (linkMessageId > 0)
{
try
{
LinkWithMessage(linkMessageId, contact.ID);
}
catch (Exception ex)
{
LogManager.GetLogger("ASC.CRM").Error(ex);
}
}
#endregion
Response.Redirect(String.Compare(e.CommandArgument.ToString(), "0", true) == 0
? String.Format("default.aspx?id={0}{1}", contact.ID,
contact is Company
? ""
: String.Format("&{0}=people", UrlConstant.Type))
: String.Format("default.aspx?action=manage{0}",
contact is Company
? ""
: String.Format("&{0}=people", UrlConstant.Type)), false);
Context.ApplicationInstance.CompleteRequest();
}
catch (Exception ex)
{
LogManager.GetLogger("ASC.CRM").Error(ex);
var cookie = HttpContext.Current.Request.Cookies.Get(ErrorCookieKey);
if (cookie == null)
{
cookie = new HttpCookie(ErrorCookieKey)
{
Value = ex.Message
};
HttpContext.Current.Response.Cookies.Add(cookie);
}
}
}
public static MethodStatus Create(string path, string name, ShareType type, uint maximumAllowed, string description, string password)
{
ManagementClass mc = new ManagementClass("Win32_Share");
object[] parameters = new object[] { path, name, (uint)type, maximumAllowed, description, password, null };
object result = mc.InvokeMethod("Create", parameters);
uint r = Convert.ToUInt32(result);
return (MethodStatus)r;
}
static public void DOShareScreenshot(string text, ShareType shareType)
{
self.ShareScreenshot(text, shareType);
}
public static void NtTransactCreateRequest(
int messageId,
int sessionId,
int treeId,
[Domain("ImpersonationLevel")] int impersonationLevel,
[Domain("FileDomain")] string fileName,
ShareType shareType,
bool isSigned)
{
smbRequest = new NtTransactCreateRequest(
messageId,
sessionId,
treeId,
impersonationLevel,
fileName,
shareType,
isSigned);
Checker.CheckNtTransactCreateRequest(
smbConnection,
messageId,
sessionId,
treeId,
shareType,
isSigned,
fileName,
smbState);
Requirement.AssumeCaptured("Send NT_TRANSACT_CREATE request");
Update.UpdateNTTransactCreateRequest(smbConnection, smbRequest);
}
public CompanyWrapper UpdateCompany(
int companyid,
string companyName,
string about,
ShareType shareType,
IEnumerable<Guid> managerList,
IEnumerable<ItemKeyValuePair<int, string>> customFieldList)
{
var companyInst = new Company
{
ID = companyid,
CompanyName = companyName,
About = about,
ShareType = shareType
};
DaoFactory.GetContactDao().UpdateContact(companyInst);
companyInst = (Company)DaoFactory.GetContactDao().GetByID(companyInst.ID);
var managerListLocal = managerList != null ? managerList.ToList(): new List<Guid>();
if (managerListLocal.Any())
{
CRMSecurity.SetAccessTo(companyInst, managerListLocal);
}
if (customFieldList != null)
{
var existingCustomFieldList = DaoFactory.GetCustomFieldDao().GetFieldsDescription(EntityType.Company).Select(fd => fd.ID).ToList();
foreach (var field in customFieldList)
{
if (string.IsNullOrEmpty(field.Value) || !existingCustomFieldList.Contains(field.Key)) continue;
DaoFactory.GetCustomFieldDao().SetFieldValue(EntityType.Company, companyInst.ID, field.Key, field.Value);
}
}
MessageService.Send(Request, MessageAction.CompanyUpdated, companyInst.GetTitle());
return (CompanyWrapper)ToContactWrapper(companyInst);
}
public static List<ShareInfo> GetShareInfo(string serverName, ShareType shareType)
{
IList<ShareType> shareTypeList = new List<ShareType>();
shareTypeList.Add(shareType);
return GetShareInfo(serverName, shareTypeList);
}
public PersonWrapper UpdatePerson(
int personid,
string firstName,
string lastName,
string jobTitle,
int companyId,
string about,
ShareType shareType,
IEnumerable<Guid> managerList,
IEnumerable<ItemKeyValuePair<int, string>> customFieldList,
IEnumerable<HttpPostedFileBase> photo)
{
if (personid <= 0 || string.IsNullOrEmpty(firstName) || string.IsNullOrEmpty(lastName)) throw new ArgumentException();
var peopleInst = new Person
{
ID = personid,
FirstName = firstName,
LastName = lastName,
JobTitle = jobTitle,
CompanyID = companyId,
About = about,
ShareType = shareType
};
DaoFactory.GetContactDao().UpdateContact(peopleInst);
peopleInst = (Person)DaoFactory.GetContactDao().GetByID(peopleInst.ID);
var managerListLocal = managerList != null ? managerList.ToList() : new List<Guid>();
if (managerListLocal.Any())
{
CRMSecurity.SetAccessTo(peopleInst, managerListLocal);
}
if (customFieldList != null)
{
var existingCustomFieldList = DaoFactory.GetCustomFieldDao().GetFieldsDescription(EntityType.Person).Select(fd => fd.ID).ToList();
foreach (var field in customFieldList)
{
if (string.IsNullOrEmpty(field.Value) || !existingCustomFieldList.Contains(field.Key)) continue;
DaoFactory.GetCustomFieldDao().SetFieldValue(EntityType.Person, peopleInst.ID, field.Key, field.Value);
}
}
var wrapper = (PersonWrapper)ToContactWrapper(peopleInst);
var photoList = photo != null ? photo.ToList() : new List<HttpPostedFileBase>();
if (photoList.Any())
{
wrapper.SmallFotoUrl = ChangeContactPhoto(peopleInst.ID, photoList);
}
MessageService.Send(Request, MessageAction.PersonUpdated, peopleInst.GetTitle());
return wrapper;
}
// 创建帖子对象
public static Post CreatePost(string text, bool commentable, ForwardType forwardType, ShareType shareType, Visibility visibility, string viewPassword,
string systemTag, string publicTags, string privateTag, Guid?circleId, double latitude, double longitude, string locationName, string address, string cityCode,
List <Guid> friendIds, List <PostAttachment> postAttachments, int score, Guid userId, bool?showOriginalText = null)
{
return(new Post(text, showOriginalText, commentable, forwardType, shareType, visibility, viewPassword, systemTag, publicTags, privateTag, circleId, latitude, longitude,
locationName, address, cityCode, friendIds, postAttachments, score, userId));
}
public ShareTypeExtended(uint shareTypeExtended)
{
ShareType = (ShareType)(shareTypeExtended & 0x0FFFFFFF);
IsSpecial = (shareTypeExtended & 0x80000000) > 0;
IsTemporary = (shareTypeExtended & 0x40000000) > 0;
}
protected void Add(string netName, string path, ShareType shareType, string remark)
{
InnerList.Add(new Share(_server, netName, shareType));
}
//按钮点击截屏分享到微信
public void BtnShareToWechatOnClick()
{
currentShareType = ShareType.WeChat;
ShowShareHUD();
}
public PersonWrapper CreatePerson(
string firstName,
string lastName,
string jobTitle,
int companyId,
string about,
ShareType shareType,
IEnumerable<Guid> managerList,
IEnumerable<ItemKeyValuePair<int, string>> customFieldList,
IEnumerable<HttpPostedFileBase> photo)
{
if (companyId > 0) {
var company = DaoFactory.GetContactDao().GetByID(companyId);
if (company == null || !CRMSecurity.CanAccessTo(company)) throw new ItemNotFoundException();
}
var peopleInst = new Person
{
FirstName = firstName,
LastName = lastName,
JobTitle = jobTitle,
CompanyID = companyId,
About = about,
ShareType = shareType
};
peopleInst.ID = DaoFactory.GetContactDao().SaveContact(peopleInst);
peopleInst.CreateBy = Core.SecurityContext.CurrentAccount.ID;
peopleInst.CreateOn = DateTime.UtcNow;
var managerListLocal = managerList != null ? managerList.ToList() : new List<Guid>();
if (managerListLocal.Any())
{
CRMSecurity.SetAccessTo(peopleInst, managerListLocal);
}
if (customFieldList != null)
{
foreach (var field in customFieldList)
{
if (string.IsNullOrEmpty(field.Value)) continue;
DaoFactory.GetCustomFieldDao().SetFieldValue(EntityType.Person, peopleInst.ID, field.Key, field.Value);
}
}
var wrapper = (PersonWrapper)ToContactWrapper(peopleInst);
var photoList = photo != null ? photo.ToList() : new List<HttpPostedFileBase>();
if (photoList.Any())
{
wrapper.SmallFotoUrl = ChangeContactPhoto(peopleInst.ID, photoList);
}
MessageService.Send(Request, MessageAction.PersonCreated, peopleInst.GetTitle());
return wrapper;
}
public static AnalyticsResult SocialShareAccept(ShareType shareType, SocialNetwork socialNetwork, string senderId = null, string recipientId = null, IDictionary <string, object> eventData = null)
{
return(SocialShareAccept(AnalyticsEnums.Get(shareType), AnalyticsEnums.Get(socialNetwork), senderId, recipientId, eventData));
}
public CompanyWrapper CreateCompany(
string companyName,
string about,
IEnumerable<int> personList,
ShareType shareType,
IEnumerable<Guid> managerList,
IEnumerable<ItemKeyValuePair<int, string>> customFieldList,
IEnumerable<HttpPostedFileBase> photo)
{
var companyInst = new Company
{
CompanyName = companyName,
About = about,
ShareType = shareType
};
companyInst.ID = DaoFactory.GetContactDao().SaveContact(companyInst);
companyInst.CreateBy = Core.SecurityContext.CurrentAccount.ID;
companyInst.CreateOn = DateTime.UtcNow;
if (personList != null)
{
foreach (var personID in personList)
{
var person = DaoFactory.GetContactDao().GetByID(personID);
if (person == null || !CRMSecurity.CanAccessTo(person)) continue;
AddPeopleToCompany(companyInst.ID, personID);
}
}
var managerListLocal = managerList != null ? managerList.ToList() : new List<Guid>();
if (managerListLocal.Any())
{
CRMSecurity.SetAccessTo(companyInst, managerListLocal);
}
if (customFieldList != null)
{
var existingCustomFieldList = DaoFactory.GetCustomFieldDao().GetFieldsDescription(EntityType.Company).Select(fd => fd.ID).ToList();
foreach (var field in customFieldList)
{
if (string.IsNullOrEmpty(field.Value) || !existingCustomFieldList.Contains(field.Key)) continue;
DaoFactory.GetCustomFieldDao().SetFieldValue(EntityType.Company, companyInst.ID, field.Key, field.Value);
}
}
var wrapper = (CompanyWrapper)ToContactWrapper(companyInst);
var photoList = photo != null ? photo.ToList() : new List<HttpPostedFileBase>();
if (photoList.Any())
{
wrapper.SmallFotoUrl = ChangeContactPhoto(companyInst.ID, photoList);
}
MessageService.Send(Request, MessageAction.CompanyCreated, companyInst.GetTitle());
return wrapper;
}
// 构造帖子对象
private Post(string text, bool?showOriginalText, bool commentable, ForwardType forwardType, ShareType shareType, Visibility visibility, string viewPassword,
string systemTag, string publicTags, string privateTag, Guid?circleId, double latitude, double longitude, string locationName, string address, string cityCode,
List <Guid> friendIds, List <PostAttachment> postAttachments, int score, Guid userId)
: this(text, latitude, longitude, locationName, address, cityCode, postAttachments, userId)
{
// 发送标签更新事件
AddTagChangedDomainEvent(publicTags);
Commentable = commentable;
ForwardType = forwardType;
ShareType = shareType;
Visibility = visibility;
ViewPassword = viewPassword;
SystemTag = systemTag;
PublicTags = publicTags;
PrivateTag = privateTag;
CircleId = circleId;
_userPostRelations = friendIds?.Select(id => new UserPostRelation(id, UserPostRelationType.View)).ToList();
PostType = PostType.Post;
ShowOriginalText = showOriginalText;
Score = score;
LastScoreRefreshedTime = (DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0)).TotalSeconds;
// 公开帖子需要审核通过后才能显示
PostAuthStatus = visibility == Visibility.Public ? PostAuthStatus.Authenticating : PostAuthStatus.Authenticated;
}
