Aan Kurniawan ¹ and Zainal A. Hasibuan ²
Faculty of Computer Science, University of Indonesia
email: aan.kurniawan@ui.ac.id ¹, zhasibua@cs.ui.ac.id ²

ABSTRACT

Educational resources usually reside in the digital library, e-learning and e-laboratory systems. Many of the systems have been developed using different technologies, platforms, protocols and architectures. These systems maintain a large number of digital objects that are stored in many different storage systems and data formats with differences in: schema, access rights, metadata attributes, and ontologies. This study proposes a generic architecture for sharing educational resources in the heterogeneous environments using data grid. The architecture is designed based on the two common types of data: structured and unstructured data. This architecture will improve the accessibility, integration and management of those educational resources.

Keywords: resource sharing, data grid, digital library

1. INTRODUCTION

Currently, the increasing social demands on high quality educational resources of higher education cannot be fulfilled only by the available educators and conventional libraries. With the advances of information technology, many learning materials and academic journals created by universities have been converted into digital objects. The rapid growth of Internet infrastructure accelerates the transformation of conventional libraries and learning to the digital libraries and e-learning. This transformation greatly affects the way of people to get information and learn. Accessing information and learning now can be done from anywhere at any time.

Since many digital library, e-learning and e-laboratory systems have been developed using different technologies, platforms, protocols and architectures, they will potentially introduce the problem of information islands. In order to address this problem, some previous works [1][2][3][4] proposed the use of grid technology that has the capability of integrating the heterogeneous platforms. However, most of them considered that the shared resources are only files or unstructured data. Educational resources consist of not only unstructured data, but also structured data. Much information such as the metadata describing the shared digital objects and the XML formatted documents is stored in a database. This information also needs to be shared with other systems.

In this study, we propose a generic architecture for sharing educational resources in heterogeneous environment using data grid. We also show how this architecture applies in the digital libraries using Indonesian Higher Education Network (INHERENT) [5].

2. INHERENT

INHERENT (Indonesian Higher Education Network) [5] is a network backbone that is developed by Indonesian government to facilitate the interconnection among the higher education institutions (HEIs) in Indonesia. The project was proposed by the directorate of higher education. Started on July 2006, currently it connects 82 state HEIs, 12 regional offices of the coordination of private HEIs, and 150 private HEIs (see Figure 1).

All state HEIs in Java are connected by STM-1 National Backbone with the bandwidth of 155 Mbps. Other cities in the other islands use 8-Mbps leased line and 2-Mbps VSAT connections.

Figure 1. Indonesian Higher Education Network in 2009 [5]

This network has been used for various educational activities including video-conferencing and distance learning. Every university can build their own digital libraries and learning management systems (LMSs) and then publish their educational resources through the network. Although the resources can be shared to each another via FTP or web servers, the systems (digital libraries and LMSs) cannot provide an integrated view to users. Users still have to access every digital library systems in order to find the resources required by them. This network has a potential of sharing various educational resources using data grid as proposed in [6].

3. DATA GRID

Data grid is one of the types of grid technologies. The other types are computational and access grid. Originally, the emphasis of grid technology lay in the sharing of computational resources [7]. Technological and scientific advances have led to an ongoing data explosion in many fields. Data are stored in many different storage systems and data formats with different schema, access rights, metadata attributes, and ontologies. These data also need to be shared and managed. The need then introduces a new grid technology, namely data grid. There are some existing data grids. In the following, we will overview two of them (iRODS and OGSA-DAI) and highlight their features to address the need.

• iRODS

iRODS (Integrated Rule-Oriented Data System) [8] is a second generation data grid system providing a unified view and seamless access to distributed digital objects across a wide area network. It is extended from the Storage Resource Broker (SRB) that is considered as the first generation data grid system. Both SRB and iRODS are developed by the San Diego Supercomputing Center (SDSC).

Classified as the first generation of the data grid, SRB is mainly focused on providing a unified view over distributed storages based on logical naming concepts using the client-server architecture. The concepts facilitated the naming and location transparency where users, resources, data objects and virtual directories were abstracted by logical names and mapped onto physical entities. The mapping is done at run time by the Virtualization sub-system. The information of the mapping from the logical name to physical name is maintained persistently in a database system called the Metadata Catalog. The database also maintains the metadata of the data objects that use the schema of attribute-value pair and the states of data and operations. Built upon this logical abstraction, iRODS takes one level higher by abstracting the data management process itself called policy abstraction.

iRODS Architecture

Figure 2. iRODS Architecture [8]

Whilst the policies used for managing the data at the server level in SRB are hard-coded, iRODS uses another approach, Rule-oriented Programming (ROP), to make the customization of data management functionalities much easier. Rules are explicitly declared to control the operations performed when a rule is invoked by a particular task. In iRODS, these operations are called micro services and implemented as functions in C programming language.

Figure 2 displays the iRODS architecture with its main modules. The architecture differentiates between the administrative commands needed to manage the rules, and the rules that invoke data management modules. When a user invokes a service, it fires a rule that uses the information from the rule base, status, and metadata catalog to invoke micro-services [9]. The micro-services either change the metadata catalog or change the resource (read/write/create/etc).

Figure 3 illustrates a scenario when a client sends a query asking for a file from an iRODS zone. Firstly, he connects to one of iRODS servers (for example server A) using a client application and sends the criteria of the file needed (e.g. based on the metadata, filename, size, etc). The request is directed to server A that will find the file using information available in Metadata catalog. The query result is sent back to the client. If he/she wants to get the file, server A asks the catalog server which iRODS server that stores the file (for example in the server B). Server A then communicates with server B to request the file. Server B applies the rules related with the request. The rules can be the process of authorization (whether the client has a privilege to read the file) and sending the file to the client using iRODS native protocol. The client is not aware of the location of the file. This location transparency is handled by the grid.

Figure 3. A client asks for a file from an iRODS data grid [8]

Based on the explanation above, we conclude that iRODS focuses on managing unstructured data objects such as files. Although it can also access structured data resources, its orientation is mainly on distributed file management. However, it also uses structure data (relational database) to manage the metadata of the data objects, the states of data and the states of operations. The metadata can potentially be integrated using the OGSA-DAI data grid.

• OGSA-DAI

OGSA-DAI (Open Grid Services Architecture – Data Access and Integration) [10] is a middleware software that allows structured data resources, such as relational or XML databases, from multiple, distributed, heterogeneous and autonomously managed data sources to be easily accessed via web services. It focuses on cases where the assembly of all the data into a single data warehouse is inappropriate [10].

Figure 4. An overview of OGSA-DAI components [11]

OGSA-DAI is designed to enable sharing of data resources to make collaboration that supports:

1. Data access service, which allows to access structured data in distributed heterogeneous data resources
2. Data transformation service, which allows to expose data in schema X to users as data in schema Y
3. Data integration service, which allows to expose multiple databases to users as a single virtual database
4. Data delivery service, which allows to deliver data to where it’s needed by the most appropriate means, such as Web service, email, HTTP, FTP and GridFTP

OGSA-DAI has adopted a service oriented architecture (SOA) solution for integrating data and grids through the use of web services. The role of OGSA-DAI in a service-based Grid, illustrated in Figure 4, involves interactions between several following components [11]:

1. OGSA-DAI data service: a web service that implements various port types allowing the submission of requests and data transport operations
2. Client: an entity that submits a request to the OGSA-DAI data service. A request is in the form of a perform document that describes one or more activities to be carried out by the service.
3. Consumer: a process, other than the client, to which an OGSA-DAI service delivers data.
4. Producer: a process, other than the client, that sends data to an OGSA-DAI data service.

When a client wants to make a request to an OGSA-DAI data service, it invokes a web service operation on the data service using a perform document. A perform document is an XML document describing the request that the client wants to be executed, defined by linking together a sequence of activities. An activity is an OGSA-DAI construct corresponding to a specific task that should be performed. The output of one activity can be linked to the input of another to perform a number of tasks in sequence.  A range of activities is supported by OGSA-DAI, falling into the broad categories of relational activities, XML activities, delivery activities, transformation activities and file activities. Furthermore, the activity is an OGSA-DAI extensibility point, allowing third parties to define new activities and add them to the ones supported by an OGSA-DAI data service.

OGSA-DAI focuses on managing heterogeneous structured data resources. Although it can also access the unstructured data using file transfer, its orientation is mainly on structured data (such as relational and XML database) management.

According to the two existing data grid middlewares, there are two main orientations in handling data based on the nature of data: structured and unstructured data. In the following section, we propose a system architecture that accommodates these two kinds of data.

4. THE PROPOSED ARCHITECTURE

In this study, a generic architecture for sharing educational resources in heterogeneous environment using data grid middleware is proposed based on the two types of data: structured and unstructured data.

From the perspective of computer processing, the digital objects are merely data. Generally, data can be classified into two categories: unstructured and structured data. Unstructured data consists of any data stored in an unstructured format at an atomic level. There is no conceptual definition and no data type definition in the unstructured content. Furthermore, unstructured data can be divided into two basic categories: bitmap objects (such as video, image, and audio files) and textual objects (such as spreadsheets, presentations, documents, and email). Both of them can be treated as a string of bits. The unstructured data is usually managed by operating system. Structured data has schema information that describes its structure. The schema can be separated from the data (such as in relational database) or it can be mixed with the data (e.g.  XML format). The structured data is usually managed by a database management system. The system facilitates the processes of defining, constructing, manipulating, and sharing the data among various users and applications [12]. This differentiation of the nature of data brings into different treatment when the various formats of data and storage systems are handled in the middleware layer.

The Proposed Architecture

Figure 5. The proposed generic architecture for resource sharing

Figure 5 shows the proposed architecture that utilizes the similar hierarchy used in [13] but it is applied in managing heterogeneous data resources. The architecture consists of three layers: data layer, data grid middleware layer and application layer.

At the data layer, the various data resources in the heterogeneous file systems and storage systems can be joined into one large data collection. We distinguish between structured and unstructured data because of their different inherent characteristics. At the data grid middleware layer, the data virtualizations for each data type are separated. The unstructured data are virtualized by file-oriented data grid middleware, such as SRB and iRODS, while the structured data virtualization is handled by database-oriented data grid middleware, such as OGSA-DAI.

Based on the analysis of the file-orientated data grids (such as SRB and iRODS), the unstructured data virtualization provides the following basic services [14]:

1. Data storage and replication service, which allows to store any type of digital object content and to replicate it into several other resources. The service is independent of the content type because only the clients need to be aware of the content internal format and structure.
2. Composition and relation service, which allows to define various relations between digital objects and to define multiple groups of related objects. Those relations may be used to create complex digital objects, to show parent/child relationships between objects or to create collections of digital objects.
3. Search service, which allows to search in previously defined sets of digital objects. The search can be based on the query matching with the metadata catalog.
4. Metadata storage service, which allows to store metadata describing digital objects. One object can be described in many metadata records. The metadata also records information associated with replication. These records can be utilized for the search service. Usually, database systems are used to store and manage the metadata. Furthermore, some database systems containing metadata can be integrated using structured data virtualization components of the data grid middleware.

The structured data virtualization provides the four basic services as described in the section of OGSA-DAI.

At the application layer, data-intensive applications, such as e-learning management systems and digital libraries, can utilize the two data virtualizations in order to publish and share their digital content objects.

Figure 6. A typical implementation of the proposed architecture for digital library

Figure 6 shows a typical implementation of the proposed architecture for digital library. Every digital library sites that are registered in the Integrated Higher Education Digital Library Portal manage their own data resources consisting of the collection of digital objects and structured data (relational database and XML). The digital objects are stored in various storage systems that are managed by iRODS storage servers. Since all of iRODS servers are registered in one zone, namely Zone IDL (Indonesian Digital Libraries), the digital objects can be replicated among the servers. Some files of site A can be replicated to the servers of site B, and vice versa. The metadata catalog servers in both sites will contain the same information of all collected educational resources.

Some digital library systems store index files for the use of searching in relational databases. The systems can also manage some kinds of educational resources formatted in XML (e.g. semi-structured documents) using native XML databases. All of this information can be accessed and integrated by the Integrated Higher Education Digital Library Portal using OGSA-DAI. Therefore, a user can do distributed searching for files stored in all resources of both sites. The integrated system also enables a user to get all resources closer to him if the resources are already replicated to some locations.

Since all sites are connected in INHERENT with high-speed bandwidth, there is no need for the Integrated Higher Education Digital Library Portal to harvest the metadata from all member sites such as proposed in [4]. No central metadata repository is required. This ensures that the query results of distributed searching will always be up to date because they come from the local query processing of each member sites.

5. CONCLUSION

In this study, we propose a generic architecture for sharing educational resources in the heterogeneous environment. The architecture distinguishes the managed data into two categories, namely structured and unstructured data. The data grid middleware used for virtualization is separated based on the two categories of data. In our design, we use iRODS and OGSA-DAI as the data grid middleware. iRODS is mainly file-oriented data grid and uses its own protocols. OGSA-DAI is mainly database-oriented and can only be accessed through web service mechanism. The combination of the two data grids completely handles all kinds of data types. Hence, this architecture can improve the accessibility, integration and management of those educational resources.

6. REFERENCES

In order to change a local user’s password in the computer being used, we can run this command:
net user username new_password

For example, to change the local administrator’s password :
net user administrator mypasswd

Of course, we must have the administrator’s privilege of the computer to make the script effective.

To change a local user’s password in another computer, we have to make connection to the IPC$ of the computer.
Use this command:
net use \\computer_name\ipc$ /user:administrator
Press Enter and then enter the administrator’s password when prompted.
Example : to change the administrator’s password of the computer WS010:
net use \\WS010\ipc$ /user:administrator

We will use Automatic Task service to change the local administrator’s password of the computer. So, we need the current time on the computer using this command :
net time \\WS010
Here is the sample output:
Current time at \\WS010 is 4/7/2007 11:35 AM

Next, we submit a job that will be executed in later time:
at \\WS010 11:50 cmd /c net user administrator mypasswd
Note:
11:50 is the time when the job will be executed.
mypasswd is the new password.

Since the computer names in my LAN have the pattern WS001, WS002, … until WS150, it is easier to use the following script:

for /l %%L in (1,1,9) do at \\WS00%%L 18:00 cmd /c net user administrator mypasswd
for /l %%L in (10,1,99) do at \\WS0%%L 18:00 cmd /c net user administrator mypasswd
for /l %%L in (100,1,150) do at \\WS%%L 18:00 cmd /c net user administrator mypasswd

The script is stored in a batch file (.bat) and then run from Windows explorer.

USE master
GO
IF OBJECT_ID ( 'sp_hexadecimal' ) IS NOT NULL
    DROP PROCEDURE sp_hexadecimal
GO
CREATE PROCEDURE sp_hexadecimal
    @binvalue varbinary(256),
    @hexvalue varchar (514) OUTPUT
AS
DECLARE @charvalue varchar (514)
DECLARE @i int
DECLARE @length int
DECLARE @hexstring char(16)
SELECT @charvalue = '0x'
SELECT @i = 1
SELECT @length = DATALENGTH (@binvalue)
SELECT @hexstring = '0123456789ABCDEF'
WHILE (@i <= @length)
BEGIN
  DECLARE @tempint int
  DECLARE @firstint int
  DECLARE @secondint int
  SELECT @tempint = CONVERT(int, SUBSTRING(@binvalue,@i,1))
  SELECT @firstint = FLOOR(@tempint/16)
  SELECT @secondint = @tempint - (@firstint*16)
  SELECT @charvalue = @charvalue +
    SUBSTRING(@hexstring, @firstint+1, 1) +
    SUBSTRING(@hexstring, @secondint+1, 1)
  SELECT @i = @i + 1
END

SELECT @hexvalue = @charvalue
GO

IF OBJECT_ID ( 'sp_help_revlogin' ) IS NOT NULL
  DROP PROCEDURE sp_help_revlogin
GO
CREATE PROCEDURE sp_help_revlogin @login_name sysname = NULL AS
DECLARE @name sysname
DECLARE @type varchar (1)
DECLARE @hasaccess int
DECLARE @denylogin int
DECLARE @is_disabled int
DECLARE @PWD_varbinary  varbinary (256)
DECLARE @PWD_string  varchar (514)
DECLARE @SID_varbinary varbinary (85)
DECLARE @SID_string varchar (514)
DECLARE @tmpstr  varchar (1024)
DECLARE @is_policy_checked varchar (3)
DECLARE @is_expiration_checked varchar (3)

DECLARE @defaultdb sysname

IF (@login_name IS NULL)
  DECLARE login_curs CURSOR FOR

      SELECT p.sid, p.name, p.type, p.is_disabled, p.default_database_name, l.hasaccess, l.denylogin FROM
sys.server_principals p LEFT JOIN sys.syslogins l
      ON ( l.name = p.name ) WHERE p.type IN ( 'S', 'G', 'U' ) AND p.name  'sa'
ELSE
  DECLARE login_curs CURSOR FOR

      SELECT p.sid, p.name, p.type, p.is_disabled, p.default_database_name, l.hasaccess, l.denylogin FROM
sys.server_principals p LEFT JOIN sys.syslogins l
      ON ( l.name = p.name ) WHERE p.type IN ( 'S', 'G', 'U' ) AND p.name = @login_name
OPEN login_curs

FETCH NEXT FROM login_curs INTO @SID_varbinary, @name, @type, @is_disabled, @defaultdb, @hasaccess, @denylogin
IF (@@fetch_status = -1)
BEGIN
  PRINT 'No login(s) found.'
  CLOSE login_curs
  DEALLOCATE login_curs
  RETURN -1
END
SET @tmpstr = '/* sp_help_revlogin script '
PRINT @tmpstr
SET @tmpstr = '** Generated ' + CONVERT (varchar, GETDATE()) + ' on ' + @@SERVERNAME + ' */'
PRINT @tmpstr
PRINT ''
WHILE (@@fetch_status  -1)
BEGIN
  IF (@@fetch_status  -2)
  BEGIN
    PRINT ''
    SET @tmpstr = '-- Login: ' + @name
    PRINT @tmpstr
    IF (@type IN ( 'G', 'U'))
    BEGIN -- NT authenticated account/group

      SET @tmpstr = 'CREATE LOGIN ' + QUOTENAME( @name ) + ' FROM WINDOWS WITH DEFAULT_DATABASE = [' + @defaultdb + ']'
    END
    ELSE BEGIN -- SQL Server authentication
        -- obtain password and sid
            SET @PWD_varbinary = CAST( LOGINPROPERTY( @name, 'PasswordHash' ) AS varbinary (256) )
        EXEC sp_hexadecimal @PWD_varbinary, @PWD_string OUT
        EXEC sp_hexadecimal @SID_varbinary,@SID_string OUT

        -- obtain password policy state
        SELECT @is_policy_checked = CASE is_policy_checked WHEN 1 THEN 'ON' WHEN 0 THEN 'OFF' ELSE NULL END FROM sys.sql_logins WHERE name = @name
        SELECT @is_expiration_checked = CASE is_expiration_checked WHEN 1 THEN 'ON' WHEN 0 THEN 'OFF' ELSE NULL END FROM sys.sql_logins WHERE name = @name

            SET @tmpstr = 'CREATE LOGIN ' + QUOTENAME( @name ) + ' WITH PASSWORD = ' + @PWD_string + ' HASHED, SID = ' + @SID_string + ', DEFAULT_DATABASE = [' + @defaultdb + ']'

        IF ( @is_policy_checked IS NOT NULL )
        BEGIN
          SET @tmpstr = @tmpstr + ', CHECK_POLICY = ' + @is_policy_checked
        END
        IF ( @is_expiration_checked IS NOT NULL )
        BEGIN
          SET @tmpstr = @tmpstr + ', CHECK_EXPIRATION = ' + @is_expiration_checked
        END
    END
    IF (@denylogin = 1)
    BEGIN -- login is denied access
      SET @tmpstr = @tmpstr + '; DENY CONNECT SQL TO ' + QUOTENAME( @name )
    END
    ELSE IF (@hasaccess = 0)
    BEGIN -- login exists but does not have access
      SET @tmpstr = @tmpstr + '; REVOKE CONNECT SQL TO ' + QUOTENAME( @name )
    END
    IF (@is_disabled = 1)
    BEGIN -- login is disabled
      SET @tmpstr = @tmpstr + '; ALTER LOGIN ' + QUOTENAME( @name ) + ' DISABLE'
    END
    PRINT @tmpstr
  END

  FETCH NEXT FROM login_curs INTO @SID_varbinary, @name, @type, @is_disabled, @defaultdb, @hasaccess, @denylogin
   END
CLOSE login_curs
DEALLOCATE login_curs
RETURN 0
GO

How to Use it

1. Copy the above script to a text file and save it (better with the file extension .sql)
2. Open Query Analyzer (SQL Server 2000) or SQL Server Management Studio (SQL Server 2005). Connect to the source instance using an account that has sysadmin privilege (such as : sa)
3. Open the script file and then run it. The script will create two stored procedures in master database : sp_hexadecimal and sp_help_revlogin
4. Then in master database, run :

   EXEC sp_help_revlogin

   It will generate an output script that will recreate all logins. This script creates the logins that have the original Security Identifier (SID) and the original password. Copy the script to clipboard.

5. Again, using Query Analyzer (SQL Server 2000) or SQL Server Management Studio (SQL Server 2005), connect to the target instance (of course using the account with sysadmin privilege).
6. Paste the output script generated in step 4 to a new query page and run it. Your target instance will have exactly the same logins as the source one.

<source : http://support.microsoft.com/kb/918992/>
]]> http://aank76.wordpress.com/2007/10/05/transfer-logins-and-passwords-to-another-sql-server-instance/feed/ 0 aank76 http://aank76.wordpress.com/2007/10/04/show-primary-key-of-a-table-in-oracle/ http://aank76.wordpress.com/2007/10/04/show-primary-key-of-a-table-in-oracle/#comments Thu, 04 Oct 2007 17:51:20 +0000 aank76 http://aank76.wordpress.com/?p=27 ]]> When making a query that needs joining two or more tables, you need to know the primary key/s of the tables.
The command DESCRIBE <TABLE_NAME> will not show you the primary key.
To get the primary key, use this query:

SELECT B.COLUMN_NAME FROM ALL_CONSTRAINTS A, ALL_CONS_COLUMNS B
WHERE A.CONSTRAINT_NAME=B.CONSTAINT_NAME AND A.OWNER=B.OWNER AND
A.TABLE_NAME=<TABLE_NAME> AND A.CONSTRAINT_TYPE='P';

Change <TABLE_NAME> with the table name.

The following method ensures a higher security level on the connection between MySQL server and its client. The communication between them is done on the SSH tunnel which is more secure because it uses encryption.

First thing first, make sure that the SSH server daemon is already installed in your MySQL server. You can check it by running:

ps ax | grep sshd

If you find a line containing /usr/sbin/sshd, it means the service is already installed and run. If not and you are using Ubuntu, run this command:

sudo apt-get openssh-server

Activate the service.

On the client that will connect to to MySQL server, run SSH client. For example: BitVise Tunnelier (Windows OS) can be downloaded here.

On the tab Login, insert:

• the name or the IP address of the MySQL server on the textbox Host
• username (must be registered in the server)
• choose Initial method on password

Configuring IP Forward

Open the tab C2S Fwding. Add one entry on the table, as follows:
a. Status : enabled
b. Listen Interface : 127.0.0.1
c. List. Port : 3306
d. Destination host : the name or IP address of the MySQL server
e. Dest. Port : 3306

Click the button Login. Enter the account info (username and password).

After successfully opening an SSH session, run the application (client)that will use MySQL service. Now the client computer opens the local port 3306 that will forward all communications to the MySQL server.

Direct the MySQL server address to localhost (127.0.0.1), not to the actual MySQL server.

If you use the mysql client program, run :

prompt> mysql –u root –p

Viewed on the server side, the user is accessing MySQL directly from the server with the account root@nama_server_MySQL. So use the password for local root.

For example:
You want to mount a windows shared folder with the path //winserver/shared_folder.
If you have an account in the windows computer with the username : aan, the complete username will be winserver\aan.
If the computer is member of a domain, for instance MYCOMPANYDOMAIN, and you have an account in the domain with the username aan, the complete username will be mycompanydomain\aan.
Note: the account has privilege to access the shared folder.

Prepare a credentials file.

It is a text file that contains a username and/or password of the above account with the format as follows:

username = <your_username>
password = <your_password>

For example:

username = winserver\aan #or mycompanydomain\aan if you use a domain account
password = mysecret

Save the file in a safe directory. For example, you make a directory /etc/accounts and then you save the file there with the name winaccount.
In order to prevent unauthorized access to the file, change the access permission so that only root can read the file. Use the following command:

#sudo chmod 640 /etc/accounts/winaccount

Make a mount point
This is the directory through which you will access your windows shared folder.
For example : /mnt/winfolder

Edit /etc/fstab

#sudo vi /etc/fstab

Add one entry in the last row regarding to our mounting with the column rules:

file system | mount point | type | options | dump | pass

For example, in this case:

//winserver/shared_folder /mnt/winfolder smb credentials=/etc/accounts/winaccount 0 0

Reboot your system
Now, try to reboot your Linux and you will have your windows shared folder mounted automatically in /mnt/winfolder.

You can also manually mount the windows shared folder using one of the following commands:

#sudo mount -t smbfs -o credentials=/etc/accounts/winaccount //winserver/shared_folder /mnt/winfolder

or

#sudo smbmount //winserver/shared_folder /mnt/folder -o credentials=/etc/accounts/winaccount

NOTE:
In order to mount a windows shared folder in Ubuntu, make sure that smbfs installed in your system.
If not, do this command:

#sudo apt-get install smbfs

In Ubuntu, don’t forget to always use sudo <command> to make critical changes on configuration since we usually do not use root account. So, the complete commands for changing hostname in Ubuntu are :
prompt>sudo vi /etc/hostname (change the old host name with the new one)
prompt>sudo vi /etc/hosts (idem)
prompt>sudo /etc/init.d/hostname.sh (make the changes effective)

sudo mount -t smbfs -o username=<my_windows_account> <//path_to_the_shared_folder> </mount_dir>

For example : The path of the shared folder is //myserver/mydir (use ‘/’ instead of ‘\’ in linux system) and the mount directory in my linux is /mnt/windir. My Windows domain is COMPANY and my account in the domain is aan. So, the command is :

sudo mount -t smbfs -o username=”company\aan” //myserver/mydir /mnt/windir

After I press <Enter>, the linux will prompt password, and I type my password in the COMPANY domain.

Another command that can be used to provide the same function is as follow:

sudo smbmount //myserver/mydir /mnt/windir -o username=”company\aan”

Note:

We have to ensure that our ubuntu system has smbfs installed.

Use this command to install it:

sudo apt-get install smbfs